Use a custom vtable for PyObjectRef

Author: coolreader18

vm/src/builtins/code.rs

@@ -198,7 +198,7 @@ impl PyCode {}
 #[pyimpl]
 impl PyCodeRef {
     #[pyslot]
-    fn tp_new(_cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+    fn tp_new(_cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<Self> {
         Err(vm.new_type_error("Cannot directly create code object".to_owned()))
     }
 

vm/src/builtins/object.rs

@@ -217,10 +217,10 @@ impl PyBaseObject {
     #[pyproperty(name = "__class__", setter)]
     fn set_class(instance: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         if instance.payload_is::<PyBaseObject>() {
-            match value.downcast_generic::<PyType>() {
+            match value.downcast::<PyType>() {
                 Ok(cls) => {
                     // FIXME(#1979) cls instances might have a payload
-                    *instance.typ.write() = cls;
+                    *instance.class_lock().write() = cls;
                     Ok(())
                 }
                 Err(value) => {

vm/src/builtins/pystr.rs

@@ -240,7 +240,10 @@ impl PyStr {
         if other.isinstance(&vm.ctx.types.str_type) {
             Ok(self.value.py_add(borrow_value(&other)))
         } else {
-            Err(vm.new_type_error(format!("Cannot add {} and {}", self, other)))
+            Err(vm.new_type_error(format!(
+                "can only concatenate str (not \"{}\") to str",
+                other.class().name
+            )))
         }
     }
 

vm/src/builtins/weakref.rs

@@ -2,9 +2,9 @@ use super::pytype::PyTypeRef;
 use crate::common::hash::PyHash;
 use crate::function::{FuncArgs, OptionalArg};
 use crate::pyobject::{
-    IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyObjectWeak, PyRef, PyResult, PyValue,
+    TypeProtocol,
 };
-use crate::pyobjectrc::{PyObjectRc, PyObjectWeak};
 use crate::slots::{Callable, Comparable, Hashable, PyComparisonOp};
 use crate::vm::VirtualMachine;
 
@@ -20,7 +20,7 @@ pub struct PyWeak {
 impl PyWeak {
     pub fn downgrade(obj: &PyObjectRef) -> PyWeak {
         PyWeak {
-            referent: PyObjectRc::downgrade(obj),
+            referent: PyObjectRef::downgrade(obj),
             hash: AtomicCell::new(None),
         }
     }

vm/src/bytesinner.rs

@@ -14,8 +14,8 @@ use crate::byteslike::try_bytes_like;
 use crate::cformat::CFormatBytes;
 use crate::function::{OptionalArg, OptionalOption};
 use crate::pyobject::{
-    BorrowValue, Either, IdProtocol, PyComparisonValue, PyIterable, PyObjectRef, PyRef, PyResult,
-    PyValue, TryFromObject, TypeProtocol,
+    BorrowValue, Either, IdProtocol, PyComparisonValue, PyIterable, PyObjectRef, PyResult, PyValue,
+    TryFromObject, TypeProtocol,
 };
 use crate::sliceable::PySliceableSequence;
 use crate::slots::PyComparisonOp;
@@ -91,10 +91,10 @@ impl ByteInnerNewOptions {
 
     pub fn get_bytes(mut self, cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
         let inner = if let OptionalArg::Present(source) = self.source.take() {
-            if source.class().is(&PyBytes::class(vm)) && cls.is(&PyBytes::class(vm)) {
-                return self
-                    .check_args(vm)
-                    .map(|_| unsafe { PyRef::from_obj_unchecked(source) });
+            if cls.is(&PyBytes::class(vm)) {
+                if let Ok(source) = source.clone().downcast_exact(vm) {
+                    return self.check_args(vm).map(|()| source);
+                }
             }
 
             match_class!(match source {