From c5ce44eaaa35b652b12b5a7f30908d2b9f919dd3 Mon Sep 17 00:00:00 2001 From: Kangzhi Shi Date: Tue, 21 Mar 2023 22:48:56 +0200 Subject: [PATCH] remove slots.as_number replaced with slots.number --- derive-impl/src/pyclass.rs | 6 +- vm/src/protocol/number.rs | 10 +-- vm/src/types/slot.rs | 149 +++++++++++++++++-------------------- vm/src/vm/vm_ops.rs | 6 +- 4 files changed, 81 insertions(+), 90 deletions(-) diff --git a/derive-impl/src/pyclass.rs b/derive-impl/src/pyclass.rs index 90fe03ddd..d74c8e8e4 100644 --- a/derive-impl/src/pyclass.rs +++ b/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 => diff --git a/vm/src/protocol/number.rs b/vm/src/protocol/number.rs index 55a57c231..a08ef3bbf 100644 --- a/vm/src/protocol/number.rs +++ b/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> { - 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> { - 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>> { - 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( diff --git a/vm/src/types/slot.rs b/vm/src/types/slot.rs index 352895968..dba2194a6 100644 --- a/vm/src/types/slot.rs +++ b/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>>, pub as_mapping: AtomicCell>>, @@ -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__) ); diff --git a/vm/src/vm/vm_ops.rs b/vm/src/vm/vm_ops.rs index ab5b59772..343354703 100644 --- a/vm/src/vm/vm_ops.rs +++ b/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);