no once cell

Author: youknowone

stdlib/src/math.rs

@@ -454,7 +454,7 @@ mod math {
     fn ceil(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let result_or_err = try_magic_method(identifier!(vm, __ceil__), vm, &x);
         if result_or_err.is_err() {
-            if let Ok(Some(v)) = x.try_float_opt(vm) {
+            if let Ok(Some(v)) = x.to_number().float_opt(vm) {
                 let v = try_f64_to_bigint(v.to_f64().ceil(), vm)?;
                 return Ok(vm.ctx.new_int(v).into());
             }
@@ -466,7 +466,7 @@ mod math {
     fn floor(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let result_or_err = try_magic_method(identifier!(vm, __floor__), vm, &x);
         if result_or_err.is_err() {
-            if let Ok(Some(v)) = x.try_float_opt(vm) {
+            if let Ok(Some(v)) = x.to_number().float_opt(vm) {
                 let v = try_f64_to_bigint(v.to_f64().floor(), vm)?;
                 return Ok(vm.ctx.new_int(v).into());
             }

vm/src/builtins/complex.rs

@@ -67,7 +67,7 @@ impl PyObjectRef {
         if let Some(complex) = self.payload_if_subclass::<PyComplex>(vm) {
             return Ok(Some((complex.value, true)));
         }
-        if let Some(float) = self.try_float_opt(vm)? {
+        if let Some(float) = self.to_number().float_opt(vm)? {
             return Ok(Some((Complex64::new(float.to_f64(), 0.0), false)));
         }
         Ok(None)

vm/src/builtins/float.rs

@@ -58,16 +58,6 @@ impl From<f64> for PyFloat {
     }
 }
 
-impl PyObject {
-    pub fn try_float_opt(&self, vm: &VirtualMachine) -> PyResult<Option<PyRef<PyFloat>>> {
-        PyNumber::from(self).float_opt(vm)
-    }
-
-    pub fn try_float(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyFloat>> {
-        PyNumber::from(self).float(vm)
-    }
-}
-
 pub(crate) fn to_op_float(obj: &PyObject, vm: &VirtualMachine) -> PyResult<Option<f64>> {
     let v = if let Some(float) = obj.payload_if_subclass::<PyFloat>(vm) {
         Some(float.value)
@@ -152,7 +142,7 @@ impl Constructor for PyFloat {
         let float_val = match arg {
             OptionalArg::Missing => 0.0,
             OptionalArg::Present(val) => {
-                if let Some(f) = val.try_float_opt(vm)? {
+                if let Some(f) = val.to_number().float_opt(vm)? {
                     f.value
                 } else {
                     float_from_string(val, vm)?

vm/src/builtins/int.rs

@@ -266,7 +266,7 @@ impl Constructor for PyInt {
                     val
                 };
 
-                PyNumber::from(val.as_ref())
+                val.to_number()
                     .int(vm)
                     .map(|x| x.as_bigint().clone())
             }

vm/src/builtins/type.rs

@@ -41,6 +41,12 @@ pub struct HeapTypeExt {
 
 pub struct PointerSlot<T>(NonNull<T>);
 
+impl<T> PointerSlot<T> {
+    pub unsafe fn borrow_static(&self) -> &'static T {
+        self.0.as_ref()
+    }
+}
+
 impl<T> Clone for PointerSlot<T> {
     fn clone(&self) -> Self {
         *self

vm/src/function/number.rs

@@ -1,4 +1,4 @@
-use crate::{protocol::PyNumber, AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine};
+use crate::{AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine};
 use num_complex::Complex64;
 use std::ops::Deref;
 
@@ -82,7 +82,7 @@ impl Deref for ArgIntoFloat {
 impl TryFromObject for ArgIntoFloat {
     // Equivalent to PyFloat_AsDouble.
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let value = PyNumber::from(obj.as_ref()).float(vm)?.to_f64();
+        let value = obj.to_number().float(vm)?.to_f64();
         Ok(ArgIntoFloat { value })
     }
 }

vm/src/protocol/number.rs

@@ -8,12 +8,19 @@ use crate::{
     VirtualMachine,
 };
 use crossbeam_utils::atomic::AtomicCell;
-use once_cell::sync::OnceCell;
 
 type UnaryFunc<R = PyObjectRef> = AtomicCell<Option<fn(&PyNumber, &VirtualMachine) -> PyResult<R>>>;
 type BinaryFunc<R = PyObjectRef> =
     AtomicCell<Option<fn(&PyNumber, &PyObject, &VirtualMachine) -> PyResult<R>>>;
 
+
+impl PyObject {
+    #[inline]
+    pub fn to_number(&self) -> PyNumber<'_> {
+        PyNumber::from(self)
+    }
+}
+    
 #[derive(Default)]
 pub struct PyNumberMethods {
     /* Number implementations must check *both*
@@ -107,39 +114,36 @@ impl PyNumberMethods {
 
 pub struct PyNumber<'a> {
     pub obj: &'a PyObject,
-    // some fast path do not need methods, so we do lazy initialize
-    methods: OnceCell<PointerSlot<PyNumberMethods>>,
+    methods: &'a PyNumberMethods,
 }
 
 impl<'a> From<&'a PyObject> for PyNumber<'a> {
     fn from(obj: &'a PyObject) -> Self {
+        static GLOBAL_NOT_IMPLEMENTED: PyNumberMethods = PyNumberMethods::NOT_IMPLEMENTED;
         Self {
             obj,
-            methods: OnceCell::new(),
+            methods: Self::find_methods(obj).map_or(&GLOBAL_NOT_IMPLEMENTED, |m| unsafe { m.borrow_static() }),
         }
     }
 }
 
 impl PyNumber<'_> {
-    pub fn methods(&self) -> &PyNumberMethods {
-        static GLOBAL_NOT_IMPLEMENTED: PyNumberMethods = PyNumberMethods::NOT_IMPLEMENTED;
-
-        self.methods
-            .get_or_init(|| {
-                Self::find_methods(self.obj)
-                    .unwrap_or_else(|| PointerSlot::from(&GLOBAL_NOT_IMPLEMENTED))
-            })
-            .as_ref()
-    }
-
     fn find_methods(obj: &PyObject) -> Option<PointerSlot<PyNumberMethods>> {
         obj.class().mro_find_map(|x| x.slots.as_number.load())
     }
 
+    pub fn methods(&self) -> &PyNumberMethods {
+        self.methods
+    }
+
     // PyNumber_Check
     pub fn check(obj: &PyObject) -> bool {
-        let num = PyNumber::from(obj);
-        let methods = num.methods();
+        let methods = if let Some(m) = Self::find_methods(obj) {
+            m
+        } else {
+            return false;
+        };
+        let methods = methods.as_ref();
         methods.int.load().is_some()
             || methods.index.load().is_some()
             || methods.float.load().is_some()
@@ -197,7 +201,7 @@ impl PyNumber<'_> {
             //     vm,
             // )?;
             let ret = f.invoke((), vm)?;
-            PyNumber::from(ret.as_ref()).index(vm).map_err(|_| {
+            ret.to_number().index(vm).map_err(|_| {
                 vm.new_type_error(format!(
                     "__trunc__ returned non-Integral (type {})",
                     ret.class()