Add ellipsis syntax.

Author: windelbouwman

parser/src/ast.rs

@@ -217,6 +217,7 @@ pub enum Expression {
     True,
     False,
     None,
+    Ellipsis,
 }
 
 impl Expression {
@@ -259,6 +260,7 @@ impl Expression {
             Lambda { .. } => "lambda",
             IfExpression { .. } => "conditional expression",
             True | False | None => "keyword",
+            Ellipsis => "ellipsis"
         }
     }
 }

parser/src/lexer.rs

@@ -1011,8 +1011,14 @@ where
                 Some('.') => {
                     let tok_start = self.get_pos();
                     self.next_char();
-                    let tok_end = self.get_pos();
-                    return Some(Ok((tok_start, Tok::Dot, tok_end)));
+                    if let (Some('.'), Some('.')) = (&self.chr0, &self.chr1) {
+                        self.next_char();self.next_char();
+                        let tok_end = self.get_pos();
+                        return Some(Ok((tok_start, Tok::Ellipsis, tok_end)));
+                    } else {
+                        let tok_end = self.get_pos();
+                        return Some(Ok((tok_start, Tok::Dot, tok_end)));
+                    }
                 }
                 Some('\n') => {
                     let tok_start = self.get_pos();

parser/src/python.lalrpop

@@ -839,6 +839,7 @@ Atom: ast::Expression = {
     "True" => ast::Expression::True,
     "False" => ast::Expression::False,
     "None" => ast::Expression::None,
+    "..." => ast::Expression::Ellipsis,
 };
 
 TestListComp: Vec<ast::Expression> = {
@@ -1048,6 +1049,7 @@ extern {
         "~" => lexer::Tok::Tilde,
         ":" => lexer::Tok::Colon,
         "." => lexer::Tok::Dot,
+        "..." => lexer::Tok::Ellipsis,
         "," => lexer::Tok::Comma,
         "*" => lexer::Tok::Star,
         "**" => lexer::Tok::DoubleStar,

vm/src/bytecode.rs

@@ -193,6 +193,7 @@ pub enum Constant {
     Code { code: Box<CodeObject> },
     Tuple { elements: Vec<Constant> },
     None,
+    Ellipsis,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -385,6 +386,7 @@ impl fmt::Display for Constant {
                     .join(", ")
             ),
             Constant::None => write!(f, "None"),
+            Constant::Ellipsis => write!(f, "Ellipsis"),
         }
     }
 }

vm/src/compile.rs

@@ -1056,6 +1056,11 @@ impl Compiler {
                     value: bytecode::Constant::None,
                 });
             }
+            ast::Expression::Ellipsis => {
+                self.emit(Instruction::LoadConst {
+                    value: bytecode::Constant::Ellipsis,
+                });
+            }
             ast::Expression::String { value } => {
                 self.compile_string(value)?;
             }

vm/src/pyobject.rs

@@ -130,6 +130,7 @@ pub struct PyContext {
     pub map_type: PyObjectRef,
     pub memoryview_type: PyObjectRef,
     pub none: PyObjectRef,
+    pub ellipsis: PyObjectRef,
     pub not_implemented: PyObjectRef,
     pub tuple_type: PyObjectRef,
     pub set_type: PyObjectRef,
@@ -223,6 +224,12 @@ impl PyContext {
             create_type("NoneType", &type_type, &object_type, &dict_type),
         );
 
+        // TODO: implement proper ellipsis class?
+        let ellipsis = PyObject::new(
+            PyObjectPayload::None,
+            create_type("EllipsisType", &type_type, &object_type, &dict_type),
+        );
+
         let not_implemented = PyObject::new(
             PyObjectPayload::NotImplemented,
             create_type("NotImplementedType", &type_type, &object_type, &dict_type),
@@ -263,6 +270,7 @@ impl PyContext {
             zip_type,
             dict_type,
             none,
+            ellipsis,
             not_implemented,
             str_type,
             range_type,
@@ -441,6 +449,11 @@ impl PyContext {
     pub fn none(&self) -> PyObjectRef {
         self.none.clone()
     }
+
+    pub fn ellipsis(&self) -> PyObjectRef {
+        self.ellipsis.clone()
+    }
+
     pub fn not_implemented(&self) -> PyObjectRef {
         self.not_implemented.clone()
     }
@@ -699,6 +712,7 @@ impl PyContext {
                 self.new_tuple(elements)
             }
             bytecode::Constant::None => self.none(),
+            bytecode::Constant::Ellipsis => self.ellipsis(),
         }
     }
 }

vm/src/stdlib/ast.rs

@@ -395,6 +395,9 @@ fn expression_to_ast(ctx: &PyContext, expression: &ast::Expression) -> PyObjectR
 
             node
         }
+        ast::Expression::Ellipsis => {
+            create_node(ctx, "Ellipsis")
+        }
         ast::Expression::List { elements } => {
             let node = create_node(ctx, "List");