Merge pull request RustPython#3463 from youknowone/tp-init

Add PyTypSlot::init

Author: youknowone

derive/src/pyclass.rs

@@ -381,9 +381,10 @@ pub(crate) fn impl_define_exception(exc_def: PyExceptionDef) -> Result<TokenStre
                 #slot_new_impl
             }
 
+            #[pyslot]
             #[pymethod(magic)]
             pub(crate) fn init(
-                zelf: ::rustpython_vm::PyRef<::rustpython_vm::builtins::PyBaseException>,
+                zelf: PyObjectRef,
                 args: ::rustpython_vm::function::FuncArgs,
                 vm: &::rustpython_vm::VirtualMachine,
             ) -> ::rustpython_vm::PyResult<()> {

stdlib/src/contextvars.rs

@@ -5,6 +5,7 @@ mod _contextvars {
     use crate::vm::{
         builtins::{PyFunction, PyStrRef, PyTypeRef},
         function::{ArgCallable, FuncArgs, OptionalArg},
+        types::Initializer,
         PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     };
 
@@ -13,13 +14,8 @@ mod _contextvars {
     #[derive(Debug, PyPayload)]
     struct PyContext {} // not to confuse with vm::Context
 
-    #[pyimpl]
+    #[pyimpl(with(Initializer))]
     impl PyContext {
-        #[pymethod(magic)]
-        fn init(&self, _vm: &VirtualMachine) -> PyResult<()> {
-            unimplemented!("Context.__init__ is currently under construction")
-        }
-
         #[pymethod]
         fn run(
             &self,
@@ -75,6 +71,14 @@ mod _contextvars {
         }
     }
 
+    impl Initializer for PyContext {
+        type Args = FuncArgs;
+
+        fn init(_obj: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unimplemented!("Context.__init__ is currently under construction")
+        }
+    }
+
     #[pyattr]
     #[pyclass(name)]
     #[derive(Debug, PyPayload)]
@@ -95,13 +99,8 @@ mod _contextvars {
         default: OptionalArg<PyObjectRef>,
     }
 
-    #[pyimpl]
+    #[pyimpl(with(Initializer))]
     impl ContextVar {
-        #[pymethod(magic)]
-        fn init(&self, _args: ContextVarOptions, _vm: &VirtualMachine) -> PyResult<()> {
-            unimplemented!("ContextVar.__init__() is currently under construction")
-        }
-
         #[pyproperty]
         fn name(&self) -> String {
             self.name.clone()
@@ -147,6 +146,14 @@ mod _contextvars {
         }
     }
 
+    impl Initializer for ContextVar {
+        type Args = ContextVarOptions;
+
+        fn init(_obj: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unimplemented!("ContextVar.__init__() is currently under construction")
+        }
+    }
+
     #[pyattr]
     #[pyclass(name = "Token")]
     #[derive(Debug, PyPayload)]
@@ -165,13 +172,8 @@ mod _contextvars {
         old_value: PyObjectRef,
     }
 
-    #[pyimpl]
+    #[pyimpl(with(Initializer))]
     impl ContextToken {
-        #[pymethod(magic)]
-        fn init(&self, _args: ContextTokenOptions, _vm: &VirtualMachine) -> PyResult<()> {
-            unimplemented!("Token.__init__() is currently under construction")
-        }
-
         #[pyproperty]
         fn var(&self, _vm: &VirtualMachine) -> PyObjectRef {
             unimplemented!("Token.var() is currently under construction")
@@ -188,6 +190,14 @@ mod _contextvars {
         }
     }
 
+    impl Initializer for ContextToken {
+        type Args = ContextTokenOptions;
+
+        fn init(_obj: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unimplemented!("Token.__init__() is currently under construction")
+        }
+    }
+
     #[pyfunction]
     fn copy_context() {}
 }

stdlib/src/socket.rs

@@ -14,9 +14,10 @@ mod _socket {
     use crate::vm::{
         builtins::{PyBaseExceptionRef, PyListRef, PyStrRef, PyTupleRef, PyTypeRef},
         convert::{ToPyException, ToPyObject, TryFromBorrowedObject, TryFromObject},
-        function::{ArgBytesLike, ArgMemoryBuffer, Either, FuncArgs, OptionalArg, OptionalOption},
+        function::{ArgBytesLike, ArgMemoryBuffer, Either, OptionalArg, OptionalOption},
+        types::{DefaultConstructor, Initializer},
         utils::ToCString,
-        AsObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+        AsObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     };
     use crossbeam_utils::atomic::AtomicCell;
     use num_traits::ToPrimitive;
@@ -541,20 +542,19 @@ mod _socket {
         }
     }
 
-    #[pyimpl(flags(BASETYPE))]
-    impl PySocket {
-        #[pyslot]
-        fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            Self::default().into_ref_with_type(vm, cls).map(Into::into)
-        }
+    impl DefaultConstructor for PySocket {}
+
+    impl Initializer for PySocket {
+        type Args = (
+            OptionalArg<i32>,
+            OptionalArg<i32>,
+            OptionalArg<i32>,
+            OptionalOption<PyObjectRef>,
+        );
 
-        #[pymethod(magic)]
         fn init(
-            &self,
-            family: OptionalArg<i32>,
-            socket_kind: OptionalArg<i32>,
-            proto: OptionalArg<i32>,
-            fileno: OptionalOption<PyObjectRef>,
+            zelf: PyRef<Self>,
+            (family, socket_kind, proto, fileno): Self::Args,
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             let mut family = family.unwrap_or(-1);
@@ -628,9 +628,12 @@ mod _socket {
                 )
                 .map_err(|err| err.to_pyexception(vm))?;
             };
-            self.init_inner(family, socket_kind, proto, sock, vm)
+            zelf.init_inner(family, socket_kind, proto, sock, vm)
         }
+    }
 
+    #[pyimpl(with(DefaultConstructor, Initializer), flags(BASETYPE))]
+    impl PySocket {
         #[pymethod]
         fn connect(&self, address: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             self.connect_inner(address, "connect", vm)

vm/src/builtins/bytearray.rs

@@ -30,8 +30,8 @@ use crate::{
     },
     sliceable::{SequenceIndex, SliceableSequenceMutOp, SliceableSequenceOp},
     types::{
-        AsBuffer, AsMapping, AsSequence, Callable, Comparable, Constructor, Hashable, IterNext,
-        IterNextIterable, Iterable, PyComparisonOp, Unconstructible, Unhashable,
+        AsBuffer, AsMapping, AsSequence, Callable, Comparable, Constructor, Hashable, Initializer,
+        IterNext, IterNextIterable, Iterable, PyComparisonOp, Unconstructible, Unhashable,
     },
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     TryFromBorrowedObject, TryFromObject, VirtualMachine,
@@ -95,24 +95,18 @@ pub(crate) fn init(context: &Context) {
 
 #[pyimpl(
     flags(BASETYPE),
-    with(Hashable, Comparable, AsBuffer, AsMapping, AsSequence, Iterable)
+    with(
+        Constructor,
+        Initializer,
+        Hashable,
+        Comparable,
+        AsBuffer,
+        AsMapping,
+        AsSequence,
+        Iterable
+    )
 )]
 impl PyByteArray {
-    #[pyslot]
-    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        PyByteArray::default()
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-    }
-
-    #[pymethod(magic)]
-    fn init(&self, options: ByteInnerNewOptions, vm: &VirtualMachine) -> PyResult<()> {
-        // First unpack bytearray and *then* get a lock to set it.
-        let mut inner = options.get_bytearray_inner(vm)?;
-        std::mem::swap(&mut *self.inner_mut(), &mut inner);
-        Ok(())
-    }
-
     #[cfg(debug_assertions)]
     #[pyproperty]
     fn exports(&self) -> usize {
@@ -714,6 +708,27 @@ impl PyByteArray {
     };
 }
 
+impl Constructor for PyByteArray {
+    type Args = FuncArgs;
+
+    fn py_new(cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        PyByteArray::default()
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+    }
+}
+
+impl Initializer for PyByteArray {
+    type Args = ByteInnerNewOptions;
+
+    fn init(zelf: PyRef<Self>, options: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // First unpack bytearray and *then* get a lock to set it.
+        let mut inner = options.get_bytearray_inner(vm)?;
+        std::mem::swap(&mut *zelf.inner_mut(), &mut inner);
+        Ok(())
+    }
+}
+
 impl Comparable for PyByteArray {
     fn cmp(
         zelf: &crate::Py<Self>,