Add super object type skeleton.

windelbouwman · windelbouwman · commit e3000e2f2539 · 2018-11-04T23:10:02.000+01:00
diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -531,7 +531,6 @@ fn builtin_sum(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(sum)
 }
 
-// builtin_super
 // builtin_vars
 // builtin_zip
 // builtin___import__
@@ -597,6 +596,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     dict.insert(String::from("staticmethod"), ctx.staticmethod_type());
     dict.insert(String::from("str"), ctx.str_type());
     dict.insert(String::from("sum"), ctx.new_rustfunc(builtin_sum));
+    dict.insert(String::from("super"), ctx.super_type());
     dict.insert(String::from("tuple"), ctx.tuple_type());
     dict.insert(String::from("type"), ctx.type_type());
 
diff --git a/vm/src/obj/mod.rs b/vm/src/obj/mod.rs
@@ -16,5 +16,6 @@ pub mod objproperty;
 pub mod objsequence;
 pub mod objset;
 pub mod objstr;
+pub mod objsuper;
 pub mod objtuple;
 pub mod objtype;
diff --git a/vm/src/obj/objsuper.rs b/vm/src/obj/objsuper.rs
@@ -0,0 +1,23 @@
+/*! Python `super` class.
+
+*/
+
+use super::super::pyobject::{
+    AttributeProtocol, PyContext, PyFuncArgs, PyObjectRef, PyResult, TypeProtocol,
+};
+use super::super::vm::VirtualMachine;
+use super::objtype;
+
+pub fn init(context: &PyContext) {
+    let ref super_type = context.super_type;
+    super_type.set_attr("__init__", context.new_rustfunc(super_init));
+}
+
+fn super_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    trace!("super.__init__ {:?}", args.args);
+    arg_check!(vm, args, required = [(_inst, None)]);
+
+    // TODO: implement complex logic here....
+
+    Ok(vm.get_none())
+}
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -16,6 +16,7 @@ use super::obj::objobject;
 use super::obj::objproperty;
 use super::obj::objset;
 use super::obj::objstr;
+use super::obj::objsuper;
 use super::obj::objtuple;
 use super::obj::objtype;
 use super::vm::VirtualMachine;
@@ -88,6 +89,7 @@ pub struct PyContext {
     pub tuple_type: PyObjectRef,
     pub set_type: PyObjectRef,
     pub iter_type: PyObjectRef,
+    pub super_type: PyObjectRef,
     pub str_type: PyObjectRef,
     pub function_type: PyObjectRef,
     pub property_type: PyObjectRef,
@@ -148,6 +150,7 @@ impl PyContext {
         let staticmethod_type = create_type("staticmethod", &type_type, &object_type, &dict_type);
         let function_type = create_type("function", &type_type, &object_type, &dict_type);
         let property_type = create_type("property", &type_type, &object_type, &dict_type);
+        let super_type = create_type("property", &type_type, &object_type, &dict_type);
         let generator_type = create_type("generator", &type_type, &object_type, &dict_type);
         let bound_method_type = create_type("method", &type_type, &object_type, &dict_type);
         let member_descriptor_type =
@@ -200,6 +203,7 @@ impl PyContext {
             str_type: str_type,
             object: object_type,
             function_type: function_type,
+            super_type: super_type,
             property_type: property_type,
             generator_type: generator_type,
             module_type: module_type,
@@ -223,6 +227,7 @@ impl PyContext {
         objbytearray::init(&context);
         objproperty::init(&context);
         objstr::init(&context);
+        objsuper::init(&context);
         objtuple::init(&context);
         objiter::init(&context);
         objbool::init(&context);
@@ -278,6 +283,10 @@ impl PyContext {
         self.str_type.clone()
     }
 
+    pub fn super_type(&self) -> PyObjectRef {
+        self.super_type.clone()
+    }
+
     pub fn function_type(&self) -> PyObjectRef {
         self.function_type.clone()
     }
