remove slots.as_number replaced with slots.number

derive-impl/src/pyclass.rs

@@ -703,6 +703,7 @@ where
         let tokens = {
             const NON_ATOMIC_SLOTS: &[&str] = &["as_buffer"];
             const POINTER_SLOTS: &[&str] = &["as_sequence", "as_mapping"];
+            const STATIC_GEN_SLOTS: &[&str] = &["as_number"];
 
             if NON_ATOMIC_SLOTS.contains(&slot_name.as_str()) {
                 quote_spanned! { span =>
@@ -712,10 +713,9 @@ where
                 quote_spanned! { span =>
                     slots.#slot_ident.store(Some(PointerSlot::from(Self::#ident())));
                 }
-            } else if "as_number" == slot_name.as_str() {
+            } else if STATIC_GEN_SLOTS.contains(&slot_name.as_str()) {
                 quote_spanned! { span =>
-                    slots.#slot_ident = Self::#ident();
-                    slots.number = Self::#ident().into();
+                    slots.#slot_ident = Self::#ident().into();
                 }
             } else {
                 quote_spanned! { span =>

vm/src/protocol/number.rs

@@ -424,7 +424,7 @@ impl<'a> PyNumber<'a> {
 
     // PyNumber_Check
     pub fn check(obj: &PyObject) -> bool {
-        let methods = &obj.class().slots.number;
+        let methods = &obj.class().slots.as_number;
         methods.int.load().is_some()
             || methods.index.load().is_some()
             || methods.float.load().is_some()
@@ -435,12 +435,12 @@ impl<'a> PyNumber<'a> {
 impl PyNumber<'_> {
     // PyIndex_Check
     pub fn is_index(self) -> bool {
-        self.class().slots.number.index.load().is_some()
+        self.class().slots.as_number.index.load().is_some()
     }
 
     #[inline]
     pub fn int(self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
-        self.class().slots.number.int.load().map(|f| {
+        self.class().slots.as_number.int.load().map(|f| {
             let ret = f(self, vm)?;
             let value = if !ret.class().is(PyInt::class(&vm.ctx)) {
                 warnings::warn(
@@ -464,7 +464,7 @@ impl PyNumber<'_> {
 
     #[inline]
     pub fn index(self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
-        self.class().slots.number.index.load().map(|f| {
+        self.class().slots.as_number.index.load().map(|f| {
             let ret = f(self, vm)?;
             let value = if !ret.class().is(PyInt::class(&vm.ctx)) {
                 warnings::warn(
@@ -488,7 +488,7 @@ impl PyNumber<'_> {
 
     #[inline]
     pub fn float(self, vm: &VirtualMachine) -> Option<PyResult<PyRef<PyFloat>>> {
-        self.class().slots.number.float.load().map(|f| {
+        self.class().slots.as_number.float.load().map(|f| {
             let ret = f(self, vm)?;
             let value = if !ret.class().is(PyFloat::class(&vm.ctx)) {
                 warnings::warn(

vm/src/types/slot.rs

@@ -27,6 +27,7 @@ macro_rules! atomic_func {
 
 // The corresponding field in CPython is `tp_` prefixed.
 // e.g. name -> tp_name
+#[derive(Default)]
 #[non_exhaustive]
 pub struct PyTypeSlots {
     /// # Safety
@@ -40,10 +41,7 @@ pub struct PyTypeSlots {
     // Methods to implement standard operations
 
     // Method suites for standard classes
-    /// # Safety
-    /// use only when initializing
-    /// use slot number for protocol
-    pub(crate) as_number: &'static PyNumberMethods,
+    pub as_number: PyNumberSlots,
     pub as_sequence: AtomicCell<Option<PointerSlot<PySequenceMethods>>>,
     pub as_mapping: AtomicCell<Option<PointerSlot<PyMappingMethods>>>,
 
@@ -92,37 +90,6 @@ pub struct PyTypeSlots {
 
     // The count of tp_members.
     pub member_count: usize,
-    pub number: PyNumberSlots,
-}
-
-impl Default for PyTypeSlots {
-    fn default() -> Self {
-        Self {
-            name: Default::default(),
-            basicsize: Default::default(),
-            as_number: PyNumberMethods::not_implemented(),
-            as_sequence: Default::default(),
-            as_mapping: Default::default(),
-            hash: Default::default(),
-            call: Default::default(),
-            repr: Default::default(),
-            getattro: Default::default(),
-            setattro: Default::default(),
-            as_buffer: Default::default(),
-            richcompare: Default::default(),
-            iter: Default::default(),
-            iternext: Default::default(),
-            flags: Default::default(),
-            doc: Default::default(),
-            descr_get: Default::default(),
-            descr_set: Default::default(),
-            init: Default::default(),
-            new: Default::default(),
-            del: Default::default(),
-            member_count: Default::default(),
-            number: Default::default(),
-        }
-    }
 }
 
 impl PyTypeSlots {
@@ -547,213 +514,237 @@ impl PyType {
                 toggle_slot!(del, del_wrapper);
             }
             _ if name == identifier!(ctx, __int__) => {
-                toggle_subslot!(number, int, int_wrapper);
+                toggle_subslot!(as_number, int, int_wrapper);
             }
             _ if name == identifier!(ctx, __index__) => {
-                toggle_subslot!(number, index, index_wrapper);
+                toggle_subslot!(as_number, index, index_wrapper);
             }
             _ if name == identifier!(ctx, __float__) => {
-                toggle_subslot!(number, float, float_wrapper);
+                toggle_subslot!(as_number, float, float_wrapper);
             }
             _ if name == identifier!(ctx, __add__) => {
-                toggle_subslot!(number, add, number_binary_op_wrapper!(__add__));
+                toggle_subslot!(as_number, add, number_binary_op_wrapper!(__add__));
             }
             _ if name == identifier!(ctx, __radd__) => {
-                toggle_subslot!(number, right_add, number_binary_right_op_wrapper!(__radd__));
+                toggle_subslot!(
+                    as_number,
+                    right_add,
+                    number_binary_right_op_wrapper!(__radd__)
+                );
             }
             _ if name == identifier!(ctx, __iadd__) => {
-                toggle_subslot!(number, inplace_add, number_binary_op_wrapper!(__iadd__));
+                toggle_subslot!(as_number, inplace_add, number_binary_op_wrapper!(__iadd__));
             }
             _ if name == identifier!(ctx, __sub__) => {
-                toggle_subslot!(number, subtract, number_binary_op_wrapper!(__sub__));
+                toggle_subslot!(as_number, subtract, number_binary_op_wrapper!(__sub__));
             }
             _ if name == identifier!(ctx, __rsub__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_subtract,
                     number_binary_right_op_wrapper!(__rsub__)
                 );
             }
             _ if name == identifier!(ctx, __isub__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     inplace_subtract,
                     number_binary_op_wrapper!(__isub__)
                 );
             }
             _ if name == identifier!(ctx, __mul__) => {
-                toggle_subslot!(number, multiply, number_binary_op_wrapper!(__mul__));
+                toggle_subslot!(as_number, multiply, number_binary_op_wrapper!(__mul__));
             }
             _ if name == identifier!(ctx, __rmul__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_multiply,
                     number_binary_right_op_wrapper!(__rmul__)
                 );
             }
             _ if name == identifier!(ctx, __imul__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     inplace_multiply,
                     number_binary_op_wrapper!(__imul__)
                 );
             }
             _ if name == identifier!(ctx, __mod__) => {
-                toggle_subslot!(number, remainder, number_binary_op_wrapper!(__mod__));
+                toggle_subslot!(as_number, remainder, number_binary_op_wrapper!(__mod__));
             }
             _ if name == identifier!(ctx, __rmod__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_remainder,
                     number_binary_right_op_wrapper!(__rmod__)
                 );
             }
             _ if name == identifier!(ctx, __imod__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     inplace_remainder,
                     number_binary_op_wrapper!(__imod__)
                 );
             }
             _ if name == identifier!(ctx, __divmod__) => {
-                toggle_subslot!(number, divmod, number_binary_op_wrapper!(__divmod__));
+                toggle_subslot!(as_number, divmod, number_binary_op_wrapper!(__divmod__));
             }
             _ if name == identifier!(ctx, __rdivmod__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_divmod,
                     number_binary_right_op_wrapper!(__rdivmod__)
                 );
             }
             _ if name == identifier!(ctx, __pow__) => {
-                toggle_subslot!(number, power, number_binary_op_wrapper!(__pow__));
+                toggle_subslot!(as_number, power, number_binary_op_wrapper!(__pow__));
             }
             _ if name == identifier!(ctx, __rpow__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_power,
                     number_binary_right_op_wrapper!(__rpow__)
                 );
             }
             _ if name == identifier!(ctx, __ipow__) => {
-                toggle_subslot!(number, inplace_power, number_binary_op_wrapper!(__ipow__));
+                toggle_subslot!(
+                    as_number,
+                    inplace_power,
+                    number_binary_op_wrapper!(__ipow__)
+                );
             }
             _ if name == identifier!(ctx, __lshift__) => {
-                toggle_subslot!(number, lshift, number_binary_op_wrapper!(__lshift__));
+                toggle_subslot!(as_number, lshift, number_binary_op_wrapper!(__lshift__));
             }
             _ if name == identifier!(ctx, __rlshift__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_lshift,
                     number_binary_right_op_wrapper!(__rlshift__)
                 );
             }
             _ if name == identifier!(ctx, __ilshift__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     inplace_lshift,
                     number_binary_op_wrapper!(__ilshift__)
                 );
             }
             _ if name == identifier!(ctx, __rshift__) => {
-                toggle_subslot!(number, rshift, number_binary_op_wrapper!(__rshift__));
+                toggle_subslot!(as_number, rshift, number_binary_op_wrapper!(__rshift__));
             }
             _ if name == identifier!(ctx, __rrshift__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_rshift,
                     number_binary_right_op_wrapper!(__rrshift__)
                 );
             }
             _ if name == identifier!(ctx, __irshift__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     inplace_rshift,
                     number_binary_op_wrapper!(__irshift__)
                 );
             }
             _ if name == identifier!(ctx, __and__) => {
-                toggle_subslot!(number, and, number_binary_op_wrapper!(__and__));
+                toggle_subslot!(as_number, and, number_binary_op_wrapper!(__and__));
             }
             _ if name == identifier!(ctx, __rand__) => {
-                toggle_subslot!(number, right_and, number_binary_right_op_wrapper!(__rand__));
+                toggle_subslot!(
+                    as_number,
+                    right_and,
+                    number_binary_right_op_wrapper!(__rand__)
+                );
             }
             _ if name == identifier!(ctx, __iand__) => {
-                toggle_subslot!(number, inplace_and, number_binary_op_wrapper!(__iand__));
+                toggle_subslot!(as_number, inplace_and, number_binary_op_wrapper!(__iand__));
             }
             _ if name == identifier!(ctx, __xor__) => {
-                toggle_subslot!(number, xor, number_binary_op_wrapper!(__xor__));
+                toggle_subslot!(as_number, xor, number_binary_op_wrapper!(__xor__));
             }
             _ if name == identifier!(ctx, __rxor__) => {
-                toggle_subslot!(number, right_xor, number_binary_right_op_wrapper!(__rxor__));
+                toggle_subslot!(
+                    as_number,
+                    right_xor,
+                    number_binary_right_op_wrapper!(__rxor__)
+                );
             }
             _ if name == identifier!(ctx, __ixor__) => {
-                toggle_subslot!(number, inplace_xor, number_binary_op_wrapper!(__ixor__));
+                toggle_subslot!(as_number, inplace_xor, number_binary_op_wrapper!(__ixor__));
             }
             _ if name == identifier!(ctx, __or__) => {
-                toggle_subslot!(number, or, number_binary_op_wrapper!(__or__));
+                toggle_subslot!(as_number, or, number_binary_op_wrapper!(__or__));
             }
             _ if name == identifier!(ctx, __ror__) => {
-                toggle_subslot!(number, right_or, number_binary_right_op_wrapper!(__ror__));
+                toggle_subslot!(
+                    as_number,
+                    right_or,
+                    number_binary_right_op_wrapper!(__ror__)
+                );
             }
             _ if name == identifier!(ctx, __ior__) => {
-                toggle_subslot!(number, inplace_or, number_binary_op_wrapper!(__ior__));
+                toggle_subslot!(as_number, inplace_or, number_binary_op_wrapper!(__ior__));
             }
             _ if name == identifier!(ctx, __floordiv__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     floor_divide,
                     number_binary_op_wrapper!(__floordiv__)
                 );
             }
             _ if name == identifier!(ctx, __rfloordiv__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_floor_divide,
                     number_binary_right_op_wrapper!(__rfloordiv__)
                 );
             }
             _ if name == identifier!(ctx, __ifloordiv__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     inplace_floor_divide,
                     number_binary_op_wrapper!(__ifloordiv__)
                 );
             }
             _ if name == identifier!(ctx, __truediv__) => {
-                toggle_subslot!(number, true_divide, number_binary_op_wrapper!(__truediv__));
+                toggle_subslot!(
+                    as_number,
+                    true_divide,
+                    number_binary_op_wrapper!(__truediv__)
+                );
             }
             _ if name == identifier!(ctx, __rtruediv__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_true_divide,
                     number_binary_right_op_wrapper!(__rtruediv__)
                 );
             }
             _ if name == identifier!(ctx, __itruediv__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     inplace_true_divide,
                     number_binary_op_wrapper!(__itruediv__)
                 );
             }
             _ if name == identifier!(ctx, __matmul__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     matrix_multiply,
                     number_binary_op_wrapper!(__matmul__)
                 );
             }
             _ if name == identifier!(ctx, __rmatmul__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     right_matrix_multiply,
                     number_binary_right_op_wrapper!(__rmatmul__)
                 );
             }
             _ if name == identifier!(ctx, __imatmul__) => {
                 toggle_subslot!(
-                    number,
+                    as_number,
                     inplace_matrix_multiply,
                     number_binary_op_wrapper!(__imatmul__)
                 );

vm/src/vm/vm_ops.rs

@@ -135,11 +135,11 @@ impl VirtualMachine {
         let class_a = a.class();
         let class_b = b.class();
 
-        let slot_a = class_a.slots.number.left_binary_op(op_slot);
+        let slot_a = class_a.slots.as_number.left_binary_op(op_slot);
         let mut slot_b = None;
 
         if !class_a.is(class_b) {
-            let slot_bb = class_b.slots.number.right_binary_op(op_slot);
+            let slot_bb = class_b.slots.as_number.right_binary_op(op_slot);
             if slot_bb.map(|x| x as usize) != slot_a.map(|x| x as usize) {
                 slot_b = slot_bb;
             }
@@ -205,7 +205,7 @@ impl VirtualMachine {
         iop_slot: PyNumberBinaryOp,
         op_slot: PyNumberBinaryOp,
     ) -> PyResult {
-        if let Some(slot) = a.class().slots.number.left_binary_op(iop_slot) {
+        if let Some(slot) = a.class().slots.as_number.left_binary_op(iop_slot) {
             let x = slot(a, b, self)?;
             if !x.is(&self.ctx.not_implemented) {
                 return Ok(x);