RustPython · youknowone · Jul 29, 2025 · Jul 3, 2025
diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs
@@ -73,8 +73,9 @@ pub(crate) fn init(context: &Context) {
 }
 
 impl PyByteArray {
+    #[deprecated(note = "use PyByteArray::from(...).into_ref() instead")]
     pub fn new_ref(data: Vec<u8>, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::from(data), ctx.types.bytearray_type.to_owned(), None)
+        Self::from(data).into_ref(ctx)
     }
 
     const fn from_inner(inner: PyBytesInner) -> Self {

diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs
@@ -99,8 +99,9 @@ impl Constructor for PyBytes {
 }
 
 impl PyBytes {
+    #[deprecated(note = "use PyBytes::from(...).into_ref() instead")]
     pub fn new_ref(data: Vec<u8>, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::from(data), ctx.types.bytes_type.to_owned(), None)
+        Self::from(data).into_ref(ctx)
     }
 
     fn _getitem(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {

diff --git a/vm/src/builtins/classmethod.rs b/vm/src/builtins/classmethod.rs
@@ -111,14 +111,9 @@ impl Initializer for PyClassMethod {
 }
 
 impl PyClassMethod {
+    #[deprecated(note = "use PyClassMethod::from(...).into_ref() instead")]
     pub fn new_ref(callable: PyObjectRef, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(
-            Self {
-                callable: PyMutex::new(callable),
-            },
-            ctx.types.classmethod_type.to_owned(),
-            None,
-        )
+        Self::from(callable).into_ref(ctx)
     }
 }
 

diff --git a/vm/src/builtins/complex.rs b/vm/src/builtins/complex.rs
@@ -29,12 +29,6 @@ pub struct PyComplex {
     value: Complex64,
 }
 
-impl PyComplex {
-    pub const fn to_complex64(self) -> Complex64 {
-        self.value
-    }
-}
-
 impl PyPayload for PyComplex {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
@@ -234,13 +228,30 @@ impl Constructor for PyComplex {
 }
 
 impl PyComplex {
+    #[deprecated(note = "use PyComplex::from(...).into_ref() instead")]
     pub fn new_ref(value: Complex64, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::from(value), ctx.types.complex_type.to_owned(), None)
+        Self::from(value).into_ref(ctx)
+    }
+
+    pub const fn to_complex64(self) -> Complex64 {
+        self.value
     }
 
     pub const fn to_complex(&self) -> Complex64 {
         self.value
     }
+
+    fn number_op<F, R>(a: &PyObject, b: &PyObject, op: F, vm: &VirtualMachine) -> PyResult
+    where
+        F: FnOnce(Complex64, Complex64, &VirtualMachine) -> R,
+        R: ToPyResult,
+    {
+        if let (Some(a), Some(b)) = (to_op_complex(a, vm)?, to_op_complex(b, vm)?) {
+            op(a, b, vm).to_pyresult(vm)
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
 }
 
 #[pyclass(
@@ -503,20 +514,6 @@ impl Representable for PyComplex {
     }
 }
 
-impl PyComplex {
-    fn number_op<F, R>(a: &PyObject, b: &PyObject, op: F, vm: &VirtualMachine) -> PyResult
-    where
-        F: FnOnce(Complex64, Complex64, &VirtualMachine) -> R,
-        R: ToPyResult,
-    {
-        if let (Some(a), Some(b)) = (to_op_complex(a, vm)?, to_op_complex(b, vm)?) {
-            op(a, b, vm).to_pyresult(vm)
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
-    }
-}
-
 #[derive(FromArgs)]
 pub struct ComplexArgs {
     #[pyarg(any, optional)]

diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs
@@ -51,8 +51,9 @@ impl PyPayload for PyDict {
 }
 
 impl PyDict {
+    #[deprecated(note = "use PyDict::default().into_ref() instead")]
     pub fn new_ref(ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::default(), ctx.types.dict_type.to_owned(), None)
+        Self::default().into_ref(ctx)
     }
 
     /// escape hatch to access the underlying data structure directly. prefer adding a method on

diff --git a/vm/src/builtins/function.rs b/vm/src/builtins/function.rs
@@ -773,12 +773,9 @@ impl PyBoundMethod {
         Self { object, function }
     }
 
+    #[deprecated(note = "Use `Self::new(object, function).into_ref(ctx)` instead")]
     pub fn new_ref(object: PyObjectRef, function: PyObjectRef, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(
-            Self::new(object, function),
-            ctx.types.bound_method_type.to_owned(),
-            None,
-        )
+        Self::new(object, function).into_ref(ctx)
     }
 }
 

diff --git a/vm/src/builtins/list.rs b/vm/src/builtins/list.rs
@@ -63,8 +63,9 @@ impl ToPyObject for Vec<PyObjectRef> {
 }
 
 impl PyList {
+    #[deprecated(note = "use PyList::from(...).into_ref() instead")]
     pub fn new_ref(elements: Vec<PyObjectRef>, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::from(elements), ctx.types.list_type.to_owned(), None)
+        Self::from(elements).into_ref(ctx)
     }
 
     pub fn borrow_vec(&self) -> PyMappedRwLockReadGuard<'_, [PyObjectRef]> {

diff --git a/vm/src/builtins/namespace.rs b/vm/src/builtins/namespace.rs
@@ -26,16 +26,6 @@ impl PyPayload for PyNamespace {
 
 impl DefaultConstructor for PyNamespace {}
 
-impl PyNamespace {
-    pub fn new_ref(ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(
-            Self {},
-            ctx.types.namespace_type.to_owned(),
-            Some(ctx.new_dict()),
-        )
-    }
-}
-
 #[pyclass(
     flags(BASETYPE, HAS_DICT),
     with(Constructor, Initializer, Comparable, Representable)

diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs
@@ -39,10 +39,9 @@ pub struct PySet {
 }
 
 impl PySet {
+    #[deprecated(note = "Use `PySet::default().into_ref(ctx)` instead")]
     pub fn new_ref(ctx: &Context) -> PyRef<Self> {
-        // Initialized empty, as calling __hash__ is required for adding each object to the set
-        // which requires a VM context - this is done in the set code itself.
-        PyRef::new_ref(Self::default(), ctx.types.set_type.to_owned(), None)
+        Self::default().into_ref(ctx)
     }
 
     pub fn elements(&self) -> Vec<PyObjectRef> {

diff --git a/vm/src/builtins/staticmethod.rs b/vm/src/builtins/staticmethod.rs
@@ -61,14 +61,14 @@ impl Constructor for PyStaticMethod {
 }
 
 impl PyStaticMethod {
+    pub fn new(callable: PyObjectRef) -> Self {
+        Self {
+            callable: PyMutex::new(callable),
+        }
+    }
+    #[deprecated(note = "use PyStaticMethod::new(...).into_ref() instead")]
     pub fn new_ref(callable: PyObjectRef, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(
-            Self {
-                callable: PyMutex::new(callable),
-            },
-            ctx.types.staticmethod_type.to_owned(),
-            None,
-        )
+        Self::new(callable).into_ref(ctx)
     }
 }
 

diff --git a/vm/src/builtins/str.rs b/vm/src/builtins/str.rs
@@ -418,9 +418,10 @@ impl PyStr {
         unsafe { AsciiString::from_ascii_unchecked(bytes) }.into()
     }
 
+    #[deprecated(note = "use PyStr::from(...).into_ref() instead")]
     pub fn new_ref(zelf: impl Into<Self>, ctx: &Context) -> PyRef<Self> {
         let zelf = zelf.into();
-        PyRef::new_ref(zelf, ctx.types.str_type.to_owned(), None)
+        zelf.into_ref(ctx)
     }
 
     fn new_substr(&self, s: Wtf8Buf) -> Self {

diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs
@@ -193,6 +193,7 @@ impl<R> PyTuple<R> {
 }
 
 impl PyTuple<PyObjectRef> {
+    // Do not deprecate this. empty_tuple must be checked.
     pub fn new_ref(elements: Vec<PyObjectRef>, ctx: &Context) -> PyRef<Self> {
         if elements.is_empty() {
             ctx.empty_tuple.clone()

diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -756,15 +756,15 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::BuildSet { size } => {
-                let set = PySet::new_ref(&vm.ctx);
+                let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     set.add(element, vm)?;
                 }
                 self.push_value(set.into());
                 Ok(None)
             }
             bytecode::Instruction::BuildSetFromTuples { size } => {
-                let set = PySet::new_ref(&vm.ctx);
+                let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     // SAFETY: trust compiler
                     let tup = unsafe { element.downcast_unchecked::<PyTuple>() };

diff --git a/vm/src/macros.rs b/vm/src/macros.rs
@@ -46,7 +46,7 @@ macro_rules! extend_class {
 macro_rules! py_namespace {
     ( $vm:expr, { $($name:expr => $value:expr),* $(,)* }) => {
         {
-            let namespace = $crate::builtins::PyNamespace::new_ref(&$vm.ctx);
+            let namespace = $crate::object::PyPayload::into_ref($crate::builtins::PyNamespace {}, &$vm.ctx);
             let obj = $crate::object::AsObject::as_object(&namespace);
             $(
                 obj.generic_setattr($vm.ctx.intern_str($name), $crate::function::PySetterValue::Assign($value.into()), $vm).unwrap();

diff --git a/vm/src/stdlib/marshal.rs b/vm/src/stdlib/marshal.rs
@@ -14,7 +14,7 @@ mod decl {
         common::wtf8::Wtf8,
         convert::ToPyObject,
         function::{ArgBytesLike, OptionalArg},
-        object::AsObject,
+        object::{AsObject, PyPayload},
         protocol::PyBuffer,
     };
     use malachite_bigint::BigInt;
@@ -186,7 +186,7 @@ mod decl {
             it: impl Iterator<Item = Self::Value>,
         ) -> Result<Self::Value, marshal::MarshalError> {
             let vm = self.0;
-            let set = PySet::new_ref(&vm.ctx);
+            let set = PySet::default().into_ref(&vm.ctx);
             for elem in it {
                 set.add(elem, vm).unwrap()
             }