PyObject::try_float

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.to_number().float_opt(vm) {
+            if let Ok(Some(v)) = x.try_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.to_number().float_opt(vm) {
+            if let Ok(Some(v)) = x.try_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.to_number().float_opt(vm)? {
+        if let Some(float) = self.try_float_opt(vm)? {
             return Ok(Some((Complex64::new(float.to_f64(), 0.0), false)));
         }
         Ok(None)

vm/src/builtins/float.rs

@@ -142,7 +142,7 @@ impl Constructor for PyFloat {
         let float_val = match arg {
             OptionalArg::Missing => 0.0,
             OptionalArg::Present(val) => {
-                if let Some(f) = val.to_number().float_opt(vm)? {
+                if let Some(f) = val.try_float_opt(vm)? {
                     f.value
                 } else {
                     float_from_string(val, vm)?

vm/src/function/number.rs

@@ -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 = obj.to_number().float(vm)?.to_f64();
+        let value = obj.try_float(vm)?.to_f64();
         Ok(ArgIntoFloat { value })
     }
 }

vm/src/protocol/number.rs

@@ -97,6 +97,32 @@ impl PyObject {
             }
         }
     }
+
+    pub fn try_float_opt(&self, vm: &VirtualMachine) -> PyResult<Option<PyRef<PyFloat>>> {
+        let value = if let Some(float) = self.downcast_ref_if_exact::<PyFloat>(vm) {
+            Some(float.to_owned())
+        } else {
+            let number = self.to_number();
+            #[allow(clippy::manual_map)]
+            if let Some(f) = number.float(vm)? {
+                Some(f)
+            } else if let Some(i) = self.try_index_opt(vm) {
+                let value = int::try_to_float(i?.as_bigint(), vm)?;
+                Some(vm.ctx.new_float(value))
+            } else if let Some(value) = self.downcast_ref::<PyFloat>() {
+                Some(vm.ctx.new_float(value.to_f64()))
+            } else {
+                None
+            }
+        };
+        Ok(value)
+    }
+
+    #[inline]
+    pub fn try_float(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyFloat>> {
+        self.try_float_opt(vm)?
+            .ok_or_else(|| vm.new_type_error(format!("must be real number, not {}", self.class())))
+    }
 }
 
 #[derive(Default)]
@@ -284,12 +310,11 @@ impl PyNumber<'_> {
         }
     }
 
-    pub fn float_opt(&self, vm: &VirtualMachine) -> PyResult<Option<PyRef<PyFloat>>> {
-        if let Some(float) = self.obj.downcast_ref_if_exact::<PyFloat>(vm) {
-            Ok(Some(float.to_owned()))
-        } else if let Some(f) = self.methods().float.load() {
+    #[inline]
+    pub fn float(&self, vm: &VirtualMachine) -> PyResult<Option<PyRef<PyFloat>>> {
+        Ok(if let Some(f) = self.methods().float.load() {
             let ret = f(self, vm)?;
-            if !ret.class().is(PyFloat::class(vm)) {
+            Some(if !ret.class().is(PyFloat::class(vm)) {
                 warnings::warn(
                     vm.ctx.exceptions.deprecation_warning,
                     format!(
@@ -301,24 +326,12 @@ impl PyNumber<'_> {
                     1,
                     vm,
                 )?;
-                Ok(Some(vm.ctx.new_float(ret.to_f64())))
+                vm.ctx.new_float(ret.to_f64())
             } else {
-                Ok(Some(ret))
-            }
-        } else if self.methods().index.load().is_some() {
-            let i = self.obj.try_index(vm)?;
-            let value = int::try_to_float(i.as_bigint(), vm)?;
-            Ok(Some(vm.ctx.new_float(value)))
-        } else if let Some(value) = self.obj.downcast_ref::<PyFloat>() {
-            Ok(Some(vm.ctx.new_float(value.to_f64())))
+                ret
+            })
         } else {
-            Ok(None)
-        }
-    }
-
-    pub fn float(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyFloat>> {
-        self.float_opt(vm)?.ok_or_else(|| {
-            vm.new_type_error(format!("must be real number, not {}", self.obj.class()))
+            None
         })
     }
 }