Merge pull request #658 from RustPython/mro

windelbouwman · web-flow · commit caae69fc357e · 2019-03-11T17:40:09.000+01:00
Cleaner type_type declaration, and faster instance checking.
diff --git a/vm/src/obj/objtype.rs b/vm/src/obj/objtype.rs
@@ -41,39 +41,23 @@ pub fn create_type(type_type: PyObjectRef, object_type: PyObjectRef, _dict_type:
     }
 }
 
-pub fn init(context: &PyContext) {
-    let type_type = &context.type_type;
-
+pub fn init(ctx: &PyContext) {
     let type_doc = "type(object_or_name, bases, dict)\n\
                     type(object) -> the object's type\n\
                     type(name, bases, dict) -> a new type";
 
-    context.set_attr(&type_type, "__call__", context.new_rustfunc(type_call));
-    context.set_attr(&type_type, "__new__", context.new_rustfunc(type_new));
-    context.set_attr(&type_type, "__mro__", context.new_property(type_mro));
-    context.set_attr(&type_type, "__repr__", context.new_rustfunc(type_repr));
-    context.set_attr(
-        &type_type,
-        "__prepare__",
-        context.new_rustfunc(type_prepare),
-    );
-    context.set_attr(
-        &type_type,
-        "__getattribute__",
-        context.new_rustfunc(type_getattribute),
-    );
-    context.set_attr(
-        &type_type,
-        "__instancecheck__",
-        context.new_rustfunc(type_instance_check),
-    );
-    context.set_attr(
-        &type_type,
-        "__subclasscheck__",
-        context.new_rustfunc(type_subclass_check),
-    );
-    context.set_attr(&type_type, "__doc__", context.new_str(type_doc.to_string()));
-    context.set_attr(&type_type, "__dir__", context.new_rustfunc(type_dir));
+    extend_class!(&ctx, &ctx.type_type, {
+        "__call__" => ctx.new_rustfunc(type_call),
+        "__new__" => ctx.new_rustfunc(type_new),
+        "__mro__" => ctx.new_property(type_mro),
+        "__repr__" => ctx.new_rustfunc(type_repr),
+        "__prepare__" => ctx.new_rustfunc(type_prepare),
+        "__getattribute__" => ctx.new_rustfunc(type_getattribute),
+        "__instancecheck__" => ctx.new_rustfunc(type_instance_check),
+        "__subclasscheck__" => ctx.new_rustfunc(type_subclass_check),
+        "__doc__" => ctx.new_str(type_doc.to_string()),
+        "__dir__" => ctx.new_rustfunc(type_dir),
+    });
 }
 
 fn type_mro(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -97,8 +81,7 @@ fn _mro(cls: PyObjectRef) -> Option<Vec<PyObjectRef>> {
 /// Determines if `obj` actually an instance of `cls`, this doesn't call __instancecheck__, so only
 /// use this if `cls` is known to have not overridden the base __instancecheck__ magic method.
 pub fn isinstance(obj: &PyObjectRef, cls: &PyObjectRef) -> bool {
-    let mro = _mro(obj.typ()).unwrap();
-    mro.into_iter().any(|c| c.is(&cls))
+    issubclass(obj.type_ref(), &cls)
 }
 
 fn type_instance_check(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -114,8 +97,8 @@ fn type_instance_check(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 /// so only use this if `cls` is known to have not overridden the base __subclasscheck__ magic
 /// method.
 pub fn issubclass(subclass: &PyObjectRef, cls: &PyObjectRef) -> bool {
-    let mro = _mro(subclass.clone()).unwrap();
-    mro.into_iter().any(|c| c.is(&cls))
+    let ref mro = subclass.payload::<PyClass>().unwrap().mro;
+    subclass.is(&cls) || mro.iter().any(|c| c.is(&cls))
 }
 
 fn type_subclass_check(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -788,19 +788,22 @@ pub trait FromPyObjectRef {
 }
 
 pub trait TypeProtocol {
-    fn typ(&self) -> PyObjectRef;
+    fn typ(&self) -> PyObjectRef {
+        self.type_ref().clone()
+    }
+    fn type_ref(&self) -> &PyObjectRef;
 }
 
 impl TypeProtocol for PyObjectRef {
-    fn typ(&self) -> PyObjectRef {
-        (**self).typ()
+    fn type_ref(&self) -> &PyObjectRef {
+        (**self).type_ref()
     }
 }
 
 impl TypeProtocol for PyObject {
-    fn typ(&self) -> PyObjectRef {
+    fn type_ref(&self) -> &PyObjectRef {
         match self.typ {
-            Some(ref typ) => typ.clone(),
+            Some(ref typ) => &typ,
             None => panic!("Object {:?} doesn't have a type!", self),
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -788,19 +788,22 @@ pub trait FromPyObjectRef {`
`788`	`788`	`}`
`789`	`789`
`790`	`790`	`pub trait TypeProtocol {`
`791`		`- fn typ(&self) -> PyObjectRef;`
	`791`	`+ fn typ(&self) -> PyObjectRef {`
	`792`	`+ self.type_ref().clone()`
	`793`	`+ }`
	`794`	`+ fn type_ref(&self) -> &PyObjectRef;`
`792`	`795`	`}`
`793`	`796`
`794`	`797`	`impl TypeProtocol for PyObjectRef {`
`795`		`- fn typ(&self) -> PyObjectRef {`
`796`		`- (**self).typ()`
	`798`	`+ fn type_ref(&self) -> &PyObjectRef {`
	`799`	`+ (**self).type_ref()`
`797`	`800`	`}`
`798`	`801`	`}`
`799`	`802`
`800`	`803`	`impl TypeProtocol for PyObject {`
`801`		`- fn typ(&self) -> PyObjectRef {`
	`804`	`+ fn type_ref(&self) -> &PyObjectRef {`
`802`	`805`	`match self.typ {`
`803`		`- Some(ref typ) => typ.clone(),`
	`806`	`+ Some(ref typ) => &typ,`
`804`	`807`	`None => panic!("Object {:?} doesn't have a type!", self),`
`805`	`808`	`}`
`806`	`809`	`}`