Call __instancecheck__ and __subclasscheck__ as part of isinstance and issubclass

Author: skinnyBat

tests/snippets/isinstance.py

@@ -0,0 +1,54 @@
+
+class Regular:
+    pass
+
+
+assert isinstance(Regular(), Regular)
+
+
+class MCNotInstanceOf(type):
+    def __instancecheck__(self, instance):
+        return False
+
+
+class NotInstanceOf(metaclass=MCNotInstanceOf):
+    pass
+
+
+class InheritedNotInstanceOf(NotInstanceOf):
+    pass
+
+
+assert not isinstance(Regular(), NotInstanceOf)
+assert not isinstance(1, NotInstanceOf)
+
+# weird cpython behaviour if exact match then isinstance return true
+assert isinstance(NotInstanceOf(), NotInstanceOf)
+assert not NotInstanceOf.__instancecheck__(NotInstanceOf())
+assert not isinstance(InheritedNotInstanceOf(), NotInstanceOf)
+
+
+class MCAlwaysInstanceOf(type):
+    def __instancecheck__(self, instance):
+        return True
+
+
+class AlwaysInstanceOf(metaclass=MCAlwaysInstanceOf):
+    pass
+
+
+assert isinstance(AlwaysInstanceOf(), AlwaysInstanceOf)
+assert isinstance(Regular(), AlwaysInstanceOf)
+assert isinstance(1, AlwaysInstanceOf)
+
+
+class MCReturnInt(type):
+    def __instancecheck__(self, instance):
+        return 3
+
+
+class ReturnInt(metaclass=MCReturnInt):
+    pass
+
+
+assert isinstance("a", ReturnInt) is True

tests/snippets/issubclass.py

@@ -0,0 +1,63 @@
+
+class A:
+    pass
+
+
+class B(A):
+    pass
+
+
+assert issubclass(A, A)
+assert issubclass(B, A)
+assert not issubclass(A, B)
+
+
+class MCNotSubClass(type):
+    def __subclasscheck__(self, subclass):
+        return False
+
+
+class NotSubClass(metaclass=MCNotSubClass):
+    pass
+
+
+class InheritedNotSubClass(NotSubClass):
+    pass
+
+
+assert not issubclass(A, NotSubClass)
+assert not issubclass(NotSubClass, NotSubClass)
+assert not issubclass(InheritedNotSubClass, NotSubClass)
+assert not issubclass(NotSubClass, InheritedNotSubClass)
+
+
+class MCAlwaysSubClass(type):
+    def __subclasscheck__(self, subclass):
+        return True
+
+
+class AlwaysSubClass(metaclass=MCAlwaysSubClass):
+    pass
+
+
+class InheritedAlwaysSubClass(AlwaysSubClass):
+    pass
+
+
+assert issubclass(A, AlwaysSubClass)
+assert issubclass(AlwaysSubClass, AlwaysSubClass)
+assert issubclass(InheritedAlwaysSubClass, AlwaysSubClass)
+assert issubclass(AlwaysSubClass, InheritedAlwaysSubClass)
+
+
+class MCAVirtualSubClass(type):
+    def __subclasscheck__(self, subclass):
+        return subclass is A
+
+
+class AVirtualSubClass(metaclass=MCAVirtualSubClass):
+    pass
+
+
+assert issubclass(A, AVirtualSubClass)
+assert not isinstance(B, AVirtualSubClass)

vm/src/builtins.rs

@@ -198,9 +198,9 @@ fn builtin_eval(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     );
 
     // Determine code object:
-    let code_obj = if objtype::isinstance(source, &vm.ctx.code_type()) {
+    let code_obj = if objtype::real_isinstance(source, &vm.ctx.code_type()) {
         source.clone()
-    } else if objtype::isinstance(source, &vm.ctx.str_type()) {
+    } else if objtype::real_isinstance(source, &vm.ctx.str_type()) {
         let mode = compile::Mode::Eval;
         let source = objstr::get_value(source);
         // TODO: fix this newline bug:
@@ -235,7 +235,7 @@ fn builtin_exec(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     );
 
     // Determine code object:
-    let code_obj = if objtype::isinstance(source, &vm.ctx.str_type()) {
+    let code_obj = if objtype::real_isinstance(source, &vm.ctx.str_type()) {
         let mode = compile::Mode::Exec;
         let source = objstr::get_value(source);
         // TODO: fix this newline bug:
@@ -246,7 +246,7 @@ fn builtin_exec(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
                 vm.new_exception(syntax_error, err.to_string())
             },
         )?
-    } else if objtype::isinstance(source, &vm.ctx.code_type()) {
+    } else if objtype::real_isinstance(source, &vm.ctx.code_type()) {
         source.clone()
     } else {
         return Err(vm.new_type_error("source argument must be str or code object".to_string()));
@@ -349,21 +349,25 @@ fn builtin_id(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 // builtin_input
 
 fn builtin_isinstance(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(vm, args, required = [(obj, None), (typ, None)]);
+    arg_check!(
+        vm,
+        args,
+        required = [(obj, None), (typ, Some(vm.get_type()))]
+    );
 
-    let isinstance = objtype::isinstance(obj, typ);
-    Ok(vm.context().new_bool(isinstance))
+    let isinstance = objtype::isinstance(vm, obj, typ)?;
+    Ok(vm.new_bool(isinstance))
 }
 
 fn builtin_issubclass(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    if args.args.len() != 2 {
-        panic!("issubclass expects exactly two parameters");
-    }
-
-    let cls1 = &args.args[0];
-    let cls2 = &args.args[1];
+    arg_check!(
+        vm,
+        args,
+        required = [(subclass, Some(vm.get_type())), (cls, Some(vm.get_type()))]
+    );
 
-    Ok(vm.context().new_bool(objtype::issubclass(cls1, cls2)))
+    let issubclass = objtype::issubclass(vm, subclass, cls)?;
+    Ok(vm.context().new_bool(issubclass))
 }
 
 fn builtin_iter(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -501,7 +505,7 @@ fn builtin_next(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     match vm.call_method(iterator, "__next__", vec![]) {
         Ok(value) => Ok(value),
         Err(value) => {
-            if objtype::isinstance(&value, &vm.ctx.exceptions.stop_iteration) {
+            if objtype::real_isinstance(&value, &vm.ctx.exceptions.stop_iteration) {
                 match default_value {
                     None => Err(value),
                     Some(value) => Ok(value.clone()),
@@ -581,7 +585,7 @@ pub fn builtin_print(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         .get_optional_kwarg("sep")
         .filter(|obj| !obj.is(&vm.get_none()));
     if let Some(ref obj) = sep_arg {
-        if !objtype::isinstance(obj, &vm.ctx.str_type()) {
+        if !objtype::real_isinstance(obj, &vm.ctx.str_type()) {
             return Err(vm.new_type_error(format!(
                 "sep must be None or a string, not {}",
                 objtype::get_type_name(&obj.typ())
@@ -595,7 +599,7 @@ pub fn builtin_print(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         .get_optional_kwarg("end")
         .filter(|obj| !obj.is(&vm.get_none()));
     if let Some(ref obj) = end_arg {
-        if !objtype::isinstance(obj, &vm.ctx.str_type()) {
+        if !objtype::real_isinstance(obj, &vm.ctx.str_type()) {
             return Err(vm.new_type_error(format!(
                 "end must be None or a string, not {}",
                 objtype::get_type_name(&obj.typ())
@@ -818,9 +822,9 @@ pub fn builtin_build_class_(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> Py
     let mut metaclass = args.get_kwarg("metaclass", vm.get_type());
 
     for base in bases.clone() {
-        if objtype::issubclass(&base.typ(), &metaclass) {
+        if objtype::issubclass(vm, &base.typ(), &metaclass)? {
             metaclass = base.typ();
-        } else if !objtype::issubclass(&metaclass, &base.typ()) {
+        } else if !objtype::real_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()));
         }
     }

vm/src/exceptions.rs

@@ -23,11 +23,11 @@ fn exception_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 pub fn print_exception(vm: &mut VirtualMachine, exc: &PyObjectRef) {
     if let Some(tb) = exc.get_attr("__traceback__") {
         println!("Traceback (most recent call last):");
-        if objtype::isinstance(&tb, &vm.ctx.list_type()) {
+        if objtype::real_isinstance(&tb, &vm.ctx.list_type()) {
             let mut elements = objsequence::get_elements(&tb).to_vec();
             elements.reverse();
             for element in elements.iter() {
-                if objtype::isinstance(&element, &vm.ctx.tuple_type()) {
+                if objtype::real_isinstance(&element, &vm.ctx.tuple_type()) {
                     let element = objsequence::get_elements(&element);
                     let filename = if let Ok(x) = vm.to_str(&element[0]) {
                         objstr::get_value(&x)

vm/src/frame.rs

@@ -105,7 +105,7 @@ impl Frame {
                 Err(exception) => {
                     // unwind block stack on exception and find any handlers.
                     // Add an entry in the traceback:
-                    assert!(objtype::isinstance(
+                    assert!(objtype::real_isinstance(
                         &exception,
                         &vm.ctx.exceptions.base_exception_type
                     ));
@@ -514,7 +514,7 @@ impl Frame {
                     0 | 2 | 3 => panic!("Not implemented!"),
                     _ => panic!("Invalid parameter for RAISE_VARARGS, must be between 0 to 3"),
                 };
-                if objtype::isinstance(&exception, &vm.ctx.exceptions.base_exception_type) {
+                if objtype::real_isinstance(&exception, &vm.ctx.exceptions.base_exception_type) {
                     info!("Exception raised: {:?}", exception);
                     Err(exception)
                 } else {

vm/src/macros.rs

@@ -18,7 +18,8 @@ macro_rules! type_check {
         // None indicates that we have no type requirement (i.e. we accept any type)
         if let Some(expected_type) = $arg_type {
             let arg = &$args.args[$arg_count];
-            if !$crate::obj::objtype::isinstance(arg, &expected_type) {
+
+            if !$crate::obj::objtype::isinstance($vm, arg, &expected_type)? {
                 let arg_typ = arg.typ();
                 let expected_type_name = $vm.to_pystr(&expected_type)?;
                 let actual_type = $vm.to_pystr(&arg_typ)?;

vm/src/obj/objbool.rs

@@ -50,7 +50,7 @@ The class bool is a subclass of the class int, and cannot be subclassed.";
 }
 
 pub fn not(vm: &mut VirtualMachine, obj: &PyObjectRef) -> PyResult {
-    if objtype::isinstance(obj, &vm.ctx.bool_type()) {
+    if objtype::real_isinstance(obj, &vm.ctx.bool_type()) {
         let value = get_value(obj);
         Ok(vm.ctx.new_bool(!value))
     } else {

vm/src/obj/objbytearray.rs

@@ -121,7 +121,7 @@ fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(cls, None)],
         optional = [(val_option, None)]
     );
-    if !objtype::issubclass(cls, &vm.ctx.bytearray_type()) {
+    if !objtype::real_issubclass(cls, &vm.ctx.bytearray_type()) {
         return Err(vm.new_type_error(format!("{:?} is not a subtype of bytearray", cls)));
     }
 
@@ -164,7 +164,7 @@ fn bytearray_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(a, Some(vm.ctx.bytearray_type())), (b, None)]
     );
 
-    let result = if objtype::isinstance(b, &vm.ctx.bytearray_type()) {
+    let result = if objtype::real_isinstance(b, &vm.ctx.bytearray_type()) {
         get_value(a).to_vec() == get_value(b).to_vec()
     } else {
         false

vm/src/obj/objbytes.rs

@@ -52,7 +52,7 @@ fn bytes_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(cls, None)],
         optional = [(val_option, None)]
     );
-    if !objtype::issubclass(cls, &vm.ctx.bytes_type()) {
+    if !objtype::real_issubclass(cls, &vm.ctx.bytes_type()) {
         return Err(vm.new_type_error(format!("{:?} is not a subtype of bytes", cls)));
     }
 
@@ -85,7 +85,7 @@ fn bytes_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
     );
 
-    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+    let result = if objtype::real_isinstance(b, &vm.ctx.bytes_type()) {
         get_value(a).to_vec() == get_value(b).to_vec()
     } else {
         false
@@ -100,7 +100,7 @@ fn bytes_ge(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
     );
 
-    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+    let result = if objtype::real_isinstance(b, &vm.ctx.bytes_type()) {
         get_value(a).to_vec() >= get_value(b).to_vec()
     } else {
         return Err(vm.new_type_error(format!("Cannot compare {} and {} using '>'", a, b)));
@@ -115,7 +115,7 @@ fn bytes_gt(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
     );
 
-    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+    let result = if objtype::real_isinstance(b, &vm.ctx.bytes_type()) {
         get_value(a).to_vec() > get_value(b).to_vec()
     } else {
         return Err(vm.new_type_error(format!("Cannot compare {} and {} using '>='", a, b)));
@@ -130,7 +130,7 @@ fn bytes_le(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
     );
 
-    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+    let result = if objtype::real_isinstance(b, &vm.ctx.bytes_type()) {
         get_value(a).to_vec() <= get_value(b).to_vec()
     } else {
         return Err(vm.new_type_error(format!("Cannot compare {} and {} using '<'", a, b)));
@@ -145,7 +145,7 @@ fn bytes_lt(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
     );
 
-    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+    let result = if objtype::real_isinstance(b, &vm.ctx.bytes_type()) {
         get_value(a).to_vec() < get_value(b).to_vec()
     } else {
         return Err(vm.new_type_error(format!("Cannot compare {} and {} using '<='", a, b)));

vm/src/obj/objcomplex.rs

@@ -60,7 +60,7 @@ fn complex_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         optional = [(real, None), (imag, None)]
     );
 
-    if !objtype::issubclass(cls, &vm.ctx.complex_type()) {
+    if !objtype::real_issubclass(cls, &vm.ctx.complex_type()) {
         return Err(vm.new_type_error(format!("{:?} is not a subtype of complex", cls)));
     }
 
@@ -109,9 +109,9 @@ fn complex_add(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     );
 
     let v1 = get_value(i);
-    if objtype::isinstance(i2, &vm.ctx.complex_type()) {
+    if objtype::real_isinstance(i2, &vm.ctx.complex_type()) {
         Ok(vm.ctx.new_complex(v1 + get_value(i2)))
-    } else if objtype::isinstance(i2, &vm.ctx.int_type()) {
+    } else if objtype::real_isinstance(i2, &vm.ctx.int_type()) {
         Ok(vm.ctx.new_complex(Complex64::new(
             v1.re + objint::get_value(i2).to_f64().unwrap(),
             v1.im,
@@ -130,7 +130,7 @@ fn complex_radd(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
     let v1 = get_value(i);
 
-    if objtype::isinstance(i2, &vm.ctx.int_type()) {
+    if objtype::real_isinstance(i2, &vm.ctx.int_type()) {
         Ok(vm.ctx.new_complex(Complex64::new(
             v1.re + objint::get_value(i2).to_f64().unwrap(),
             v1.im,
@@ -156,14 +156,14 @@ fn complex_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
     let z = get_value(zelf);
 
-    let result = if objtype::isinstance(other, &vm.ctx.complex_type()) {
+    let result = if objtype::real_isinstance(other, &vm.ctx.complex_type()) {
         z == get_value(other)
-    } else if objtype::isinstance(other, &vm.ctx.int_type()) {
+    } else if objtype::real_isinstance(other, &vm.ctx.int_type()) {
         match objint::get_value(other).to_f64() {
             Some(f) => z.im == 0.0f64 && z.re == f,
             None => false,
         }
-    } else if objtype::isinstance(other, &vm.ctx.float_type()) {
+    } else if objtype::real_isinstance(other, &vm.ctx.float_type()) {
         z.im == 0.0 && z.re == objfloat::get_value(other)
     } else {
         return Ok(vm.ctx.not_implemented());