RustPython · windelbouwman · Nov 4, 2018 · Nov 3, 2018 · Nov 3, 2018 · Nov 3, 2018
diff --git a/tests/snippets/derived_mc.py b/tests/snippets/derived_mc.py
@@ -0,0 +1,45 @@
+class MC(type):
+    pass
+
+class MC2(MC):
+    pass
+
+class MC3(type):
+    pass
+
+class A():
+    pass
+
+assert type(A) == type
+
+class B(metaclass=MC):
+    pass
+
+assert type(B) == MC
+
+class C(B):
+    pass
+
+assert type(C) == MC
+
+class D(metaclass=MC2):
+    pass
+
+assert type(D) == MC2
+
+class E(C, D, metaclass=MC):
+    pass
+
+assert type(E) == MC2
+
+class F(metaclass=MC3):
+    pass
+
+assert type(F) == MC3
+
+try:
+    class G(D, E, F):
+        pass
+    assert False
+except TypeError:
+    pass
diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -459,7 +459,13 @@ fn builtin_pow(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 pub fn builtin_print(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     trace!("print called with {:?}", args);
+    let mut first = true;
     for a in args.args {
+        if first {
+            first = false;
+        } else {
+            print!(" ");
+        }
         let v = vm.to_str(&a)?;
         let s = objstr::get_value(&v);
         print!("{}", s);
@@ -638,10 +644,17 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
 pub fn builtin_build_class_(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
     let function = args.shift();
     let name_arg = args.shift();
-    let mut bases = args.args.clone();
-    let metaclass = args.get_kwarg("metaclass", vm.get_type());
+    let bases = args.args.clone();
+    let mut metaclass = args.get_kwarg("metaclass", vm.get_type());
+
+    for base in bases.clone() {
+        if objtype::issubclass(&base.typ(), &metaclass) {
+            metaclass = base.typ();
+        } else if !objtype::issubclass(&metaclass, &base.typ()) {
+            return Err(vm.new_type_error("metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases".to_string()));
+        }
+    }
 
-    bases.push(vm.context().object());
     let bases = vm.context().new_tuple(bases);
 
     // Prepare uses full __getattribute__ resolution chain.
@@ -663,15 +676,5 @@ pub fn builtin_build_class_(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> Py
         },
     );
 
-    // Special case: __new__ must be looked up on the metaclass, not the meta-metaclass as
-    // per vm.call(metaclass, "__new__", ...)
-    let new = metaclass.get_attr("__new__").unwrap();
-    let wrapped = vm.call_get_descriptor(new, metaclass)?;
-    vm.invoke(
-        wrapped,
-        PyFuncArgs {
-            args: vec![name_arg, bases, namespace],
-            kwargs: vec![],
-        },
-    )
+    vm.call_method(&metaclass, "__call__", vec![name_arg, bases, namespace])
 }
diff --git a/vm/src/obj/objtype.rs b/vm/src/obj/objtype.rs
@@ -115,16 +115,15 @@ pub fn type_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 pub fn type_call(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
     debug!("type_call: {:?}", args);
-    let typ = args.shift();
-    let new = typ.get_attr("__new__").unwrap();
-    let obj = vm.invoke(new, args.insert(typ.clone()))?;
-
-    if let Some(init) = obj.typ().get_attr("__init__") {
-        let res = vm.invoke(init, args.insert(obj.clone()))?;
-        // TODO: assert that return is none?
-        if !isinstance(&res, &vm.get_none()) {
-            // panic!("__init__ must return none");
-            // return Err(vm.new_type_error("__init__ must return None".to_string()));
+    let cls = args.shift();
+    let new = cls.get_attr("__new__").unwrap();
+    let new_wrapped = vm.call_get_descriptor(new, cls)?;
+    let obj = vm.invoke(new_wrapped, args.clone())?;
+
+    if let Ok(init) = vm.get_method(obj.clone(), "__init__") {
+        let res = vm.invoke(init, args)?;
+        if !res.is(&vm.get_none()) {
+            return Err(vm.new_type_error("__init__ must return None".to_string()));
         }
     }
     Ok(obj)