Add ellipsis type, test and do rustfmt.

Author: windelbouwman

parser/src/ast.rs

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

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 {

tests/snippets/ellipsis.py

@@ -0,0 +1,8 @@
+
+
+a = ...
+b = ...
+c = type(a)()  # Test singleton behavior
+
+assert a is b
+assert b is c

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;

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()))
+}

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);

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");