Add ellipsis type, test and do rustfmt.

windelbouwman · windelbouwman · commit 05929b3d7bac · 2019-03-05T07:19:00.000+01:00
diff --git a/parser/src/ast.rs b/parser/src/ast.rs
@@ -260,7 +260,7 @@ impl Expression {
             Lambda { .. } => "lambda",
             IfExpression { .. } => "conditional expression",
             True | False | None => "keyword",
-            Ellipsis => "ellipsis"
+            Ellipsis => "ellipsis",
         }
     }
 }
diff --git a/parser/src/lexer.rs b/parser/src/lexer.rs
@@ -1012,7 +1012,8 @@ where
                     let tok_start = self.get_pos();
                     self.next_char();
                     if let (Some('.'), Some('.')) = (&self.chr0, &self.chr1) {
-                        self.next_char();self.next_char();
+                        self.next_char();
+                        self.next_char();
                         let tok_end = self.get_pos();
                         return Some(Ok((tok_start, Tok::Ellipsis, tok_end)));
                     } else {
diff --git a/tests/snippets/ellipsis.py b/tests/snippets/ellipsis.py
@@ -0,0 +1,8 @@
+
+
+a = ...
+b = ...
+c = type(a)()  # Test singleton behavior
+
+assert a is b
+assert b is c
diff --git a/vm/src/obj/mod.rs b/vm/src/obj/mod.rs
@@ -6,6 +6,7 @@ pub mod objbytes;
 pub mod objcode;
 pub mod objcomplex;
 pub mod objdict;
+pub mod objellipsis;
 pub mod objenumerate;
 pub mod objfilter;
 pub mod objfloat;
diff --git a/vm/src/obj/objellipsis.rs b/vm/src/obj/objellipsis.rs
@@ -0,0 +1,22 @@
+use crate::pyobject::{PyContext, PyFuncArgs, PyResult, TypeProtocol};
+use crate::vm::VirtualMachine;
+
+pub fn init(context: &PyContext) {
+    let ellipsis_type = &context.ellipsis_type;
+    context.set_attr(ellipsis_type, "__new__", context.new_rustfunc(ellipsis_new));
+    context.set_attr(
+        ellipsis_type,
+        "__repr__",
+        context.new_rustfunc(ellipsis_repr),
+    );
+}
+
+fn ellipsis_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(_cls, None)]);
+    Ok(vm.ctx.ellipsis())
+}
+
+fn ellipsis_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(_cls, None)]);
+    Ok(vm.new_str("Ellipsis".to_string()))
+}
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -19,6 +19,7 @@ use crate::obj::objbytes;
 use crate::obj::objcode;
 use crate::obj::objcomplex::{self, PyComplex};
 use crate::obj::objdict;
+use crate::obj::objellipsis;
 use crate::obj::objenumerate;
 use crate::obj::objfilter;
 use crate::obj::objfloat::{self, PyFloat};
@@ -115,6 +116,7 @@ pub struct PyContext {
     pub classmethod_type: PyObjectRef,
     pub code_type: PyObjectRef,
     pub dict_type: PyObjectRef,
+    pub ellipsis_type: PyObjectRef,
     pub enumerate_type: PyObjectRef,
     pub filter_type: PyObjectRef,
     pub float_type: PyObjectRef,
@@ -208,6 +210,7 @@ impl PyContext {
         let bytearray_type = create_type("bytearray", &type_type, &object_type, &dict_type);
         let tuple_type = create_type("tuple", &type_type, &object_type, &dict_type);
         let iter_type = create_type("iter", &type_type, &object_type, &dict_type);
+        let ellipsis_type = create_type("EllipsisType", &type_type, &object_type, &dict_type);
         let enumerate_type = create_type("enumerate", &type_type, &object_type, &dict_type);
         let filter_type = create_type("filter", &type_type, &object_type, &dict_type);
         let map_type = create_type("map", &type_type, &object_type, &dict_type);
@@ -224,11 +227,7 @@ 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 ellipsis = PyObject::new(PyObjectPayload::None, ellipsis_type.clone());
 
         let not_implemented = PyObject::new(
             PyObjectPayload::NotImplemented,
@@ -264,6 +263,7 @@ impl PyContext {
             false_value,
             tuple_type,
             iter_type,
+            ellipsis_type,
             enumerate_type,
             filter_type,
             map_type,
@@ -308,6 +308,7 @@ impl PyContext {
         objsuper::init(&context);
         objtuple::init(&context);
         objiter::init(&context);
+        objellipsis::init(&context);
         objenumerate::init(&context);
         objfilter::init(&context);
         objmap::init(&context);
diff --git a/vm/src/stdlib/ast.rs b/vm/src/stdlib/ast.rs
@@ -395,9 +395,7 @@ fn expression_to_ast(ctx: &PyContext, expression: &ast::Expression) -> PyObjectR
 
             node
         }
-        ast::Expression::Ellipsis => {
-            create_node(ctx, "Ellipsis")
-        }
+        ast::Expression::Ellipsis => create_node(ctx, "Ellipsis"),
         ast::Expression::List { elements } => {
             let node = create_node(ctx, "List");
 

Original file line number	Diff line number	Diff line change
`@@ -260,7 +260,7 @@ impl Expression {`
`260`	`260`	`Lambda { .. } => "lambda",`
`261`	`261`	`IfExpression { .. } => "conditional expression",`
`262`	`262`	`True \| False \| None => "keyword",`
`263`		`- Ellipsis => "ellipsis"`
	`263`	`+ Ellipsis => "ellipsis",`
`264`	`264`	`}`
`265`	`265`	`}`
`266`	`266`	`}`
Original file line number	Diff line number	Diff line change
`@@ -395,9 +395,7 @@ fn expression_to_ast(ctx: &PyContext, expression: &ast::Expression) -> PyObjectR`
`395`	`395`
`396`	`396`	`node`
`397`	`397`	`}`
`398`		`- ast::Expression::Ellipsis => {`
`399`		`- create_node(ctx, "Ellipsis")`
`400`		`- }`
	`398`	`+ ast::Expression::Ellipsis => create_node(ctx, "Ellipsis"),`
`401`	`399`	`ast::Expression::List { elements } => {`
`402`	`400`	`let node = create_node(ctx, "List");`
`403`	`401`