@@ -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());
             }
 
@@ -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)
 
@@ -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)?
 
@@ -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 })
     }
 }
 
@@ -96,6 +96,32 @@ impl PyObject {
             }
         }
     }
+
+    pub fn try_float_opt(&self, vm: &VirtualMachine) -> PyResult<Option<PyRef<PyFloat>>> {
+        Ok(
+            if let Some(float) = self.downcast_ref_if_exact::<PyFloat>(vm) {
+                Some(float.to_owned())
+            } else {
+                let number = self.to_number();
+                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
+                }
+            },
+        )
+    }
+
+    #[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
         })
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ impl PyObjectRef {`
`67`	`67`	`if let Some(complex) = self.payload_if_subclass::<PyComplex>(vm) {`
`68`	`68`	`return Ok(Some((complex.value, true)));`
`69`	`69`	`}`
`70`		`- if let Some(float) = self.to_number().float_opt(vm)? {`
	`70`	`+ if let Some(float) = self.try_float_opt(vm)? {`
`71`	`71`	`return Ok(Some((Complex64::new(float.to_f64(), 0.0), false)));`
`72`	`72`	`}`
`73`	`73`	`Ok(None)`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ impl Deref for ArgIntoFloat {`
`82`	`82`	`impl TryFromObject for ArgIntoFloat {`
`83`	`83`	`// Equivalent to PyFloat_AsDouble.`
`84`	`84`	`fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {`
`85`		`- let value = obj.to_number().float(vm)?.to_f64();`
	`85`	`+ let value = obj.try_float(vm)?.to_f64();`
`86`	`86`	`Ok(ArgIntoFloat { value })`
`87`	`87`	`}`
`88`	`88`	`}`