Remove TypeProtocol::clone_class()

youknowone · youknowone · commit 29ba8956a9c6 · 2022-04-17T20:10:24.000+09:00
diff --git a/stdlib/src/array.rs b/stdlib/src/array.rs
@@ -1115,7 +1115,7 @@ mod array {
                 return Self::reduce(zelf, vm);
             }
             let array = zelf.read();
-            let cls = zelf.as_object().clone_class();
+            let cls = zelf.class().clone();
             let typecode = vm.ctx.new_str(array.typecode_str());
             let bytes = vm.ctx.new_bytes(array.get_bytes().to_vec());
             let code = MachineFormatCode::from_typecode(array.typecode()).unwrap();
@@ -1135,7 +1135,7 @@ mod array {
             vm: &VirtualMachine,
         ) -> PyResult<(PyObjectRef, PyTupleRef, Option<PyDictRef>)> {
             let array = zelf.read();
-            let cls = zelf.as_object().clone_class();
+            let cls = zelf.class().clone();
             let typecode = vm.ctx.new_str(array.typecode_str());
             let values = if array.typecode() == 'u' {
                 let s = Self::_wchar_bytes_to_string(array.get_bytes(), array.itemsize(), vm)?;
diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs
@@ -688,7 +688,7 @@ impl PyByteArray {
     ) -> (PyTypeRef, PyTupleRef, Option<PyDictRef>) {
         let bytes = PyBytes::from(zelf.borrow_buf().to_vec()).into_pyobject(vm);
         (
-            zelf.as_object().clone_class(),
+            zelf.class().clone(),
             PyTuple::new_ref(vec![bytes], &vm.ctx),
             zelf.as_object().dict(),
         )
diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs
@@ -544,7 +544,7 @@ impl PyBytes {
     ) -> (PyTypeRef, PyTupleRef, Option<PyDictRef>) {
         let bytes = PyBytes::from(zelf.inner.elements.clone()).into_pyobject(vm);
         (
-            zelf.as_object().clone_class(),
+            zelf.class().clone(),
             PyTuple::new_ref(vec![bytes], &vm.ctx),
             zelf.as_object().dict(),
         )
diff --git a/vm/src/builtins/classmethod.rs b/vm/src/builtins/classmethod.rs
@@ -52,7 +52,7 @@ impl GetDescriptor for PyClassMethod {
         vm: &VirtualMachine,
     ) -> PyResult {
         let (zelf, obj) = Self::_unwrap(zelf, obj, vm)?;
-        let cls = cls.unwrap_or_else(|| obj.clone_class().into());
+        let cls = cls.unwrap_or_else(|| obj.class().clone().into());
         Ok(PyBoundMethod::new_ref(cls, zelf.callable.clone(), &vm.ctx).into())
     }
 }
diff --git a/vm/src/builtins/enumerate.rs b/vm/src/builtins/enumerate.rs
@@ -56,7 +56,7 @@ impl PyEnumerate {
     #[pymethod(magic)]
     fn reduce(zelf: PyRef<Self>) -> (PyTypeRef, (PyIter, BigInt)) {
         (
-            zelf.clone_class(),
+            zelf.class().clone(),
             (zelf.iterator.clone(), zelf.counter.read().clone()),
         )
     }
diff --git a/vm/src/builtins/object.rs b/vm/src/builtins/object.rs
@@ -255,7 +255,7 @@ impl PyBaseObject {
 
     #[pyproperty(name = "__class__")]
     fn get_class(obj: PyObjectRef) -> PyTypeRef {
-        obj.clone_class()
+        obj.class().clone()
     }
 
     #[pyproperty(name = "__class__", setter)]
@@ -300,7 +300,7 @@ impl PyBaseObject {
     fn reduce_ex(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
         if let Some(reduce) = vm.get_attribute_opt(obj.clone(), "__reduce__")? {
             let object_reduce = vm.ctx.types.object_type.get_attr("__reduce__").unwrap();
-            let typ_obj: PyObjectRef = obj.clone_class().into();
+            let typ_obj: PyObjectRef = obj.class().clone().into();
             let class_reduce = typ_obj.get_attr("__reduce__", vm)?;
             if !class_reduce.is(&object_reduce) {
                 return vm.invoke(&reduce, ());
diff --git a/vm/src/builtins/property.rs b/vm/src/builtins/property.rs
@@ -185,7 +185,7 @@ impl PyProperty {
             deleter: PyRwLock::new(zelf.fdel()),
             doc: PyRwLock::new(None),
         }
-        .into_ref_with_type(vm, AsPyObject::clone_class(&zelf))
+        .into_ref_with_type(vm, zelf.class().clone())
     }
 
     #[pymethod]
@@ -200,7 +200,7 @@ impl PyProperty {
             deleter: PyRwLock::new(zelf.fdel()),
             doc: PyRwLock::new(None),
         }
-        .into_ref_with_type(vm, AsPyObject::clone_class(&zelf))
+        .into_ref_with_type(vm, zelf.class().clone())
     }
 
     #[pymethod]
@@ -215,7 +215,7 @@ impl PyProperty {
             deleter: PyRwLock::new(deleter.or_else(|| zelf.fdel())),
             doc: PyRwLock::new(None),
         }
-        .into_ref_with_type(vm, AsPyObject::clone_class(&zelf))
+        .into_ref_with_type(vm, zelf.class().clone())
     }
 
     #[pyproperty(magic)]
diff --git a/vm/src/builtins/pysuper.rs b/vm/src/builtins/pysuper.rs
@@ -174,10 +174,7 @@ impl GetDescriptor for PySuper {
             Ok(PySuper::new(zelf.typ.clone(), obj, vm)?.into_object(vm))
         } else {
             let obj = vm.unwrap_or_none(zelf.obj.clone().map(|(o, _)| o));
-            vm.invoke(
-                zelf.as_object().clone_class().as_object(),
-                (zelf.typ.clone(), obj),
-            )
+            vm.invoke(zelf.class().as_object(), (zelf.typ.clone(), obj))
         }
     }
 }
@@ -189,7 +186,7 @@ fn supercheck(ty: PyTypeRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<
         }
     }
     if obj.isinstance(&ty) {
-        return Ok(obj.clone_class());
+        return Ok(obj.class().clone());
     }
     let class_attr = obj.get_attr("__class__", vm)?;
     if let Ok(cls) = class_attr.downcast::<PyType>() {
diff --git a/vm/src/builtins/pytype.rs b/vm/src/builtins/pytype.rs
@@ -415,7 +415,7 @@ impl PyType {
 
         let is_type_type = metatype.is(&vm.ctx.types.type_type);
         if is_type_type && args.args.len() == 1 && args.kwargs.is_empty() {
-            return Ok(args.args[0].clone_class().into());
+            return Ok(args.args[0].class().clone().into());
         }
 
         if args.args.len() != 3 {
@@ -747,7 +747,7 @@ fn find_base_dict_descr(cls: &PyTypeRef, vm: &VirtualMachine) -> Option<PyObject
 
 fn subtype_get_dict(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     // TODO: obj.class().as_pyref() need to be supported
-    let cls = obj.clone_class();
+    let cls = obj.class().clone();
     let ret = match find_base_dict_descr(&cls, vm) {
         Some(descr) => vm.call_get_descriptor(descr, obj).unwrap_or_else(|_| {
             Err(vm.new_type_error(format!(
@@ -761,7 +761,7 @@ fn subtype_get_dict(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
 }
 
 fn subtype_set_dict(obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-    let cls = obj.clone_class();
+    let cls = obj.class().clone();
     match find_base_dict_descr(&cls, vm) {
         Some(descr) => {
             let descr_set = descr
diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs
@@ -367,7 +367,7 @@ fn reduce_set(
     vm: &VirtualMachine,
 ) -> PyResult<(PyTypeRef, PyTupleRef, Option<PyDictRef>)> {
     Ok((
-        zelf.clone_class(),
+        zelf.class().clone(),
         vm.new_tuple((extract_set(zelf)
             .unwrap_or(&PySetInner::default())
             .elements(),)),
diff --git a/vm/src/builtins/singletons.rs b/vm/src/builtins/singletons.rs
@@ -87,6 +87,6 @@ impl PyNotImplemented {
 }
 
 pub fn init(context: &PyContext) {
-    PyNone::extend_class(context, &context.none.clone_class());
-    PyNotImplemented::extend_class(context, &context.not_implemented.clone_class());
+    PyNone::extend_class(context, &context.none.class());
+    PyNotImplemented::extend_class(context, &context.not_implemented.class());
 }
diff --git a/vm/src/builtins/slice.rs b/vm/src/builtins/slice.rs
@@ -204,7 +204,7 @@ impl PySlice {
         (Option<PyObjectRef>, PyObjectRef, Option<PyObjectRef>),
     )> {
         Ok((
-            zelf.clone_class(),
+            zelf.class().clone(),
             (zelf.start.clone(), zelf.stop.clone(), zelf.step.clone()),
         ))
     }
@@ -451,5 +451,5 @@ impl PyEllipsis {
 
 pub fn init(context: &PyContext) {
     PySlice::extend_class(context, &context.types.slice_type);
-    PyEllipsis::extend_class(context, &context.ellipsis.clone_class());
+    PyEllipsis::extend_class(context, &context.ellipsis.class().clone());
 }
diff --git a/vm/src/builtins/zip.rs b/vm/src/builtins/zip.rs
@@ -1,7 +1,7 @@
 use super::PyTypeRef;
 use crate::{
     builtins::PyTupleRef,
-    function::{ArgIntoBool, IntoPyObject, OptionalArg, PosArgs},
+    function::{ArgIntoBool, OptionalArg, PosArgs},
     protocol::{PyIter, PyIterReturn},
     pyclass::PyClassImpl,
     types::{Constructor, IterNext, IterNextIterable},
@@ -42,7 +42,7 @@ impl Constructor for PyZip {
 impl PyZip {
     #[pymethod(magic)]
     fn reduce(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-        let cls = zelf.clone_class().into_pyobject(vm);
+        let cls = zelf.class().clone();
         let iterators = zelf
             .iterators
             .iter()
diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs
@@ -182,7 +182,8 @@ impl VirtualMachine {
         exc: PyBaseExceptionRef,
     ) -> (PyObjectRef, PyObjectRef, PyObjectRef) {
         let tb = exc.traceback().into_pyobject(self);
-        (exc.clone_class().into(), exc.into(), tb)
+        let class = exc.class().clone();
+        (class.into(), exc.into(), tb)
     }
 
     /// Similar to PyErr_NormalizeException in CPython
diff --git a/vm/src/protocol/object.rs b/vm/src/protocol/object.rs
@@ -430,7 +430,7 @@ impl PyObject {
         } else {
             if self.class().issubclass(&vm.ctx.types.type_type) {
                 if self.is(&vm.ctx.types.type_type) {
-                    return PyGenericAlias::new(self.clone_class(), needle, vm).into_pyresult(vm);
+                    return PyGenericAlias::new(self.class().clone(), needle, vm).into_pyresult(vm);
                 }
 
                 if let Some(class_getitem) =
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -405,10 +405,12 @@ where
     fn as_object(&self) -> &PyObject {
         self.borrow()
     }
+
     #[inline(always)]
     fn get_id(&self) -> usize {
-        self.as_object()._get_id()
+        self.as_object().unique_id()
     }
+
     #[inline(always)]
     fn is<T>(&self, other: &T) -> bool
     where
@@ -422,10 +424,6 @@ where
         self.as_object().lease_class()
     }
 
-    fn clone_class(&self) -> PyTypeRef {
-        PyLease::into_pyref(self.class())
-    }
-
     fn get_class_attr(&self, attr_name: &str) -> Option<PyObjectRef> {
         self.class().get_attr(attr_name)
     }
@@ -445,8 +443,8 @@ where
 impl<T> AsPyObject for T where T: Borrow<PyObject> {}
 
 impl PyObject {
-    #[inline]
-    fn _get_id(&self) -> usize {
+    #[inline(always)]
+    fn unique_id(&self) -> usize {
         self as *const PyObject as usize
     }
 
@@ -681,7 +679,7 @@ pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
     #[pymethod(magic)]
     fn reduce(zelf: PyRef<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
         vm.new_tuple((
-            zelf.clone_class(),
+            zelf.class().clone(),
             (vm.ctx.new_tuple(zelf.as_slice().to_vec()),),
         ))
     }
diff --git a/vm/src/stdlib/ast.rs b/vm/src/stdlib/ast.rs
@@ -33,7 +33,7 @@ mod _ast {
     impl AstNode {
         #[pymethod(magic)]
         fn init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            let obj: PyObjectRef = zelf.clone_class().into();
+            let obj: PyObjectRef = zelf.class().clone().into();
             let fields = obj.get_attr("_fields", vm)?;
             let fields: Vec<PyStrRef> = fields.try_to_value(vm)?;
             let numargs = args.args.len();
diff --git a/vm/src/stdlib/builtins.rs b/vm/src/stdlib/builtins.rs
@@ -849,7 +849,7 @@ mod builtins {
                 for base in bases.as_slice().iter() {
                     let base_class = base.class();
                     if base_class.issubclass(&metaclass) {
-                        metaclass = base.clone_class();
+                        metaclass = base.class().clone();
                     } else if !metaclass.issubclass(&base_class) {
                         return Err(vm.new_type_error(
                             "metaclass conflict: the metaclass of a derived class must be a (non-strict) \
diff --git a/vm/src/stdlib/collections.rs b/vm/src/stdlib/collections.rs
@@ -155,7 +155,7 @@ mod _collections {
                 maxlen: zelf.maxlen,
                 state: AtomicCell::new(zelf.state.load()),
             }
-            .into_ref_with_type(vm, zelf.clone_class())
+            .into_ref_with_type(vm, zelf.class().clone())
         }
 
         #[pymethod]
@@ -480,7 +480,7 @@ mod _collections {
 
         #[pymethod(magic)]
         fn reduce(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
-            let cls = zelf.clone_class();
+            let cls = zelf.class().clone();
             let value = match zelf.maxlen {
                 Some(v) => vm.new_pyobj((vm.ctx.empty_tuple.clone(), v)),
                 None => vm.ctx.empty_tuple.clone().into(),
@@ -634,7 +634,7 @@ mod _collections {
                 Exhausted => PyDeque::default().into_ref(vm),
             };
             (
-                zelf.clone_class(),
+                zelf.class().clone(),
                 (deque, vm.ctx.new_int(internal.position).into()),
             )
         }
@@ -700,7 +700,7 @@ mod _collections {
                 Exhausted => PyDeque::default().into_ref(vm),
             };
             Ok((
-                zelf.clone_class(),
+                zelf.class().clone(),
                 (deque, vm.ctx.new_int(internal.position).into()),
             ))
         }
diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs
@@ -297,7 +297,7 @@ mod decl {
 
         #[pymethod(magic)]
         fn reduce(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-            let cls = zelf.clone_class().into_pyobject(vm);
+            let cls = zelf.class().clone();
             Ok(match zelf.times {
                 Some(ref times) => vm.new_tuple((cls, (zelf.object.clone(), *times.read()))),
                 None => vm.new_tuple((cls, (zelf.object.clone(),))),
diff --git a/vm/src/stdlib/operator.rs b/vm/src/stdlib/operator.rs
@@ -452,7 +452,7 @@ mod _operator {
                     .map(|v| v.as_object().to_owned())
                     .collect(),
             );
-            Ok((zelf.clone_class(), attrs))
+            Ok((zelf.class().clone(), attrs))
         }
 
         // Go through dotted parts of string and call getattr on whatever is returned.
@@ -544,7 +544,7 @@ mod _operator {
         #[pymethod(magic)]
         fn reduce(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyObjectRef {
             let items = vm.ctx.new_tuple(zelf.items.to_vec());
-            vm.new_pyobj((zelf.clone_class(), items))
+            vm.new_pyobj((zelf.class().clone(), items))
         }
     }
     impl Constructor for PyItemGetter {
@@ -629,15 +629,15 @@ mod _operator {
             if zelf.args.kwargs.is_empty() {
                 let mut pargs = vec![zelf.name.as_object().to_owned()];
                 pargs.append(&mut zelf.args.args.clone());
-                Ok(vm.new_tuple((zelf.clone_class(), vm.ctx.new_tuple(pargs))))
+                Ok(vm.new_tuple((zelf.class().clone(), vm.ctx.new_tuple(pargs))))
             } else {
                 // If we have kwargs, create a partial function that contains them and pass back that
                 // along with the args.
                 let partial = vm.import("functools", None, 0)?.get_attr("partial", vm)?;
                 let callable = vm.invoke(
                     &partial,
                     FuncArgs::new(
-                        vec![zelf.clone_class().into(), zelf.name.as_object().to_owned()],
+                        vec![zelf.class().clone().into(), zelf.name.clone().into()],
                         KwArgs::new(zelf.args.kwargs.clone()),
                     ),
                 )?;
diff --git a/vm/src/vm_object.rs b/vm/src/vm_object.rs
@@ -102,7 +102,7 @@ impl VirtualMachine {
         descr: PyObjectRef,
         obj: PyObjectRef,
     ) -> Result<PyResult, PyObjectRef> {
-        let cls = obj.clone_class().into();
+        let cls = obj.class().clone().into();
         self.call_get_descriptor_specific(descr, Some(obj), Some(cls))
     }
 
diff --git a/vm/src/vm_ops.rs b/vm/src/vm_ops.rs
@@ -169,9 +169,9 @@ impl VirtualMachine {
         reflection: &str,
         unsupported: fn(&VirtualMachine, &PyObject, &PyObject) -> PyResult,
     ) -> PyResult {
-        if rhs.isinstance(&lhs.clone_class()) {
-            let lop = lhs.get_class_attr(reflection);
-            let rop = rhs.get_class_attr(reflection);
+        if rhs.isinstance(&lhs.class()) {
+            let lop = lhs.class().get_attr(reflection);
+            let rop = rhs.class().get_attr(reflection);
             if let Some((lop, rop)) = lop.zip(rop) {
                 if !lop.is(&rop) {
                     if let Ok(r) = self.call_or_unsupported(rhs, lhs, reflection, |vm, _, _| {

Original file line number	Diff line number	Diff line change
`@@ -688,7 +688,7 @@ impl PyByteArray {`
`688`	`688`	`) -> (PyTypeRef, PyTupleRef, Option<PyDictRef>) {`
`689`	`689`	`let bytes = PyBytes::from(zelf.borrow_buf().to_vec()).into_pyobject(vm);`
`690`	`690`	`(`
`691`		`- zelf.as_object().clone_class(),`
	`691`	`+ zelf.class().clone(),`
`692`	`692`	`PyTuple::new_ref(vec![bytes], &vm.ctx),`
`693`	`693`	`zelf.as_object().dict(),`
`694`	`694`	`)`
Original file line number	Diff line number	Diff line change
`@@ -544,7 +544,7 @@ impl PyBytes {`
`544`	`544`	`) -> (PyTypeRef, PyTupleRef, Option<PyDictRef>) {`
`545`	`545`	`let bytes = PyBytes::from(zelf.inner.elements.clone()).into_pyobject(vm);`
`546`	`546`	`(`
`547`		`- zelf.as_object().clone_class(),`
	`547`	`+ zelf.class().clone(),`
`548`	`548`	`PyTuple::new_ref(vec![bytes], &vm.ctx),`
`549`	`549`	`zelf.as_object().dict(),`
`550`	`550`	`)`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ impl GetDescriptor for PyClassMethod {`
`52`	`52`	`vm: &VirtualMachine,`
`53`	`53`	`) -> PyResult {`
`54`	`54`	`let (zelf, obj) = Self::_unwrap(zelf, obj, vm)?;`
`55`		`- let cls = cls.unwrap_or_else(\|\| obj.clone_class().into());`
	`55`	`+ let cls = cls.unwrap_or_else(\|\| obj.class().clone().into());`
`56`	`56`	`Ok(PyBoundMethod::new_ref(cls, zelf.callable.clone(), &vm.ctx).into())`
`57`	`57`	`}`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ impl PyEnumerate {`
`56`	`56`	`#[pymethod(magic)]`
`57`	`57`	`fn reduce(zelf: PyRef<Self>) -> (PyTypeRef, (PyIter, BigInt)) {`
`58`	`58`	`(`
`59`		`- zelf.clone_class(),`
	`59`	`+ zelf.class().clone(),`
`60`	`60`	`(zelf.iterator.clone(), zelf.counter.read().clone()),`
`61`	`61`	`)`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ impl PyProperty {`
`185`	`185`	`deleter: PyRwLock::new(zelf.fdel()),`
`186`	`186`	`doc: PyRwLock::new(None),`
`187`	`187`	`}`
`188`		`- .into_ref_with_type(vm, AsPyObject::clone_class(&zelf))`
	`188`	`+ .into_ref_with_type(vm, zelf.class().clone())`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`#[pymethod]`
`@@ -200,7 +200,7 @@ impl PyProperty {`
`200`	`200`	`deleter: PyRwLock::new(zelf.fdel()),`
`201`	`201`	`doc: PyRwLock::new(None),`
`202`	`202`	`}`
`203`		`- .into_ref_with_type(vm, AsPyObject::clone_class(&zelf))`
	`203`	`+ .into_ref_with_type(vm, zelf.class().clone())`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`#[pymethod]`
`@@ -215,7 +215,7 @@ impl PyProperty {`
`215`	`215`	`deleter: PyRwLock::new(deleter.or_else(\|\| zelf.fdel())),`
`216`	`216`	`doc: PyRwLock::new(None),`
`217`	`217`	`}`
`218`		`- .into_ref_with_type(vm, AsPyObject::clone_class(&zelf))`
	`218`	`+ .into_ref_with_type(vm, zelf.class().clone())`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`#[pyproperty(magic)]`
Original file line number	Diff line number	Diff line change
`@@ -174,10 +174,7 @@ impl GetDescriptor for PySuper {`
`174`	`174`	`Ok(PySuper::new(zelf.typ.clone(), obj, vm)?.into_object(vm))`
`175`	`175`	`} else {`
`176`	`176`	`let obj = vm.unwrap_or_none(zelf.obj.clone().map(\|(o, _)\| o));`
`177`		`- vm.invoke(`
`178`		`- zelf.as_object().clone_class().as_object(),`
`179`		`- (zelf.typ.clone(), obj),`
`180`		`- )`
	`177`	`+ vm.invoke(zelf.class().as_object(), (zelf.typ.clone(), obj))`
`181`	`178`	`}`
`182`	`179`	`}`
`183`	`180`	`}`
`@@ -189,7 +186,7 @@ fn supercheck(ty: PyTypeRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<`
`189`	`186`	`}`
`190`	`187`	`}`
`191`	`188`	`if obj.isinstance(&ty) {`
`192`		`- return Ok(obj.clone_class());`
	`189`	`+ return Ok(obj.class().clone());`
`193`	`190`	`}`
`194`	`191`	`let class_attr = obj.get_attr("__class__", vm)?;`
`195`	`192`	`if let Ok(cls) = class_attr.downcast::<PyType>() {`