make get_method_or_type_error() error message lazy

mkurnikov · mkurnikov · commit 8a5182a8a19d · 2019-06-07T16:08:37.000+03:00
diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -31,11 +31,9 @@ use crate::vm::VirtualMachine;
 use crate::stdlib::io::io_open;
 
 fn builtin_abs(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    let method = vm.get_method_or_type_error(
-        x.clone(),
-        "__abs__",
-        format!("bad operand type for abs(): '{}'", x.class().name),
-    )?;
+    let method = vm.get_method_or_type_error(x.clone(), "__abs__", || {
+        format!("bad operand type for abs(): '{}'", x.class().name)
+    })?;
     vm.invoke(method, PyFuncArgs::new(vec![], vec![]))
 }
 
@@ -369,11 +367,9 @@ fn builtin_iter(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 fn builtin_len(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(obj, None)]);
-    let method = vm.get_method_or_type_error(
-        obj.clone(),
-        "__len__",
-        format!("object of type '{}' has no len()", obj.class().name),
-    )?;
+    let method = vm.get_method_or_type_error(obj.clone(), "__len__", || {
+        format!("object of type '{}' has no len()", obj.class().name)
+    })?;
     vm.invoke(method, PyFuncArgs::default())
 }
 
@@ -671,11 +667,9 @@ fn builtin_reversed(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(obj, None)]);
 
     // TODO: fallback to using __len__ and __getitem__, if object supports sequence protocol
-    let method = vm.get_method_or_type_error(
-        obj.clone(),
-        "__reversed__",
-        format!("argument to reversed() must be a sequence"),
-    )?;
+    let method = vm.get_method_or_type_error(obj.clone(), "__reversed__", || {
+        format!("argument to reversed() must be a sequence")
+    })?;
     vm.invoke(method, PyFuncArgs::default())
 }
 
diff --git a/vm/src/obj/objfloat.rs b/vm/src/obj/objfloat.rs
@@ -557,14 +557,12 @@ pub fn make_float(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<f64> {
     if objtype::isinstance(obj, &vm.ctx.float_type()) {
         Ok(get_value(obj))
     } else {
-        let method = vm.get_method_or_type_error(
-            obj.clone(),
-            "__float__",
+        let method = vm.get_method_or_type_error(obj.clone(), "__float__", || {
             format!(
                 "float() argument must be a string or a number, not '{}'",
                 obj.class().name
-            ),
-        )?;
+            )
+        })?;
         let result = vm.invoke(method, vec![])?;
         Ok(get_value(&result))
     }
diff --git a/vm/src/obj/objint.rs b/vm/src/obj/objint.rs
@@ -657,12 +657,9 @@ pub fn to_int(vm: &VirtualMachine, obj: &PyObjectRef, base: u32) -> PyResult<Big
                 )))
         },
         obj => {
-            let method = vm.get_method_or_type_error(
-                    obj.clone(),
-                    "__int__",
-                    format!("int() argument must be a string or a number, not '{}'",
-                            obj.class().name)
-            )?;
+            let method = vm.get_method_or_type_error(obj.clone(), "__int__", || {
+                format!("int() argument must be a string or a number, not '{}'", obj.class().name)
+            })?;
             let result = vm.invoke(method, PyFuncArgs::default())?;
             match result.payload::<PyInt>() {
                 Some(int_obj) => Ok(int_obj.as_bigint().clone()),
diff --git a/vm/src/obj/objiter.rs b/vm/src/obj/objiter.rs
@@ -22,11 +22,9 @@ pub fn get_iter(vm: &VirtualMachine, iter_target: &PyObjectRef) -> PyResult {
         let method = method_or_err?;
         vm.invoke(method, vec![])
     } else {
-        vm.get_method_or_type_error(
-            iter_target.clone(),
-            "__getitem__",
-            format!("Cannot iterate over {}", iter_target.class().name),
-        )?;
+        vm.get_method_or_type_error(iter_target.clone(), "__getitem__", || {
+            format!("Cannot iterate over {}", iter_target.class().name)
+        })?;
         let obj_iterator = PySequenceIterator {
             position: Cell::new(0),
             obj: iter_target.clone(),
diff --git a/vm/src/obj/objstr.rs b/vm/src/obj/objstr.rs
@@ -869,11 +869,9 @@ impl PyString {
     // https://docs.python.org/3/library/stdtypes.html#str.translate
     #[pymethod]
     fn translate(&self, table: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
-        vm.get_method_or_type_error(
-            table.clone(),
-            "__getitem__",
-            format!("'{}' object is not subscriptable", table.class().name),
-        )?;
+        vm.get_method_or_type_error(table.clone(), "__getitem__", || {
+            format!("'{}' object is not subscriptable", table.class().name)
+        })?;
 
         let mut translated = String::new();
         for c in self.value.chars() {
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -1141,11 +1141,9 @@ where
                 _item: std::marker::PhantomData,
             })
         } else {
-            vm.get_method_or_type_error(
-                obj.clone(),
-                "__getitem__",
-                format!("'{}' object is not iterable", obj.class().name),
-            )?;
+            vm.get_method_or_type_error(obj.clone(), "__getitem__", || {
+                format!("'{}' object is not iterable", obj.class().name)
+            })?;
             Self::try_from_object(
                 vm,
                 objiter::PySequenceIterator {
diff --git a/vm/src/stdlib/math.rs b/vm/src/stdlib/math.rs
@@ -173,15 +173,13 @@ fn math_lgamma(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
 }
 
 fn try_magic_method(func_name: &str, vm: &VirtualMachine, value: &PyObjectRef) -> PyResult {
-    let method = vm.get_method_or_type_error(
-        value.clone(),
-        func_name,
+    let method = vm.get_method_or_type_error(value.clone(), func_name, || {
         format!(
             "type '{}' doesn't define '{}' method",
             value.class().name,
             func_name,
-        ),
-    )?;
+        )
+    })?;
     vm.invoke(method, vec![])
 }
 
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -624,16 +624,19 @@ impl VirtualMachine {
 
     // get_method should be used for internal access to magic methods (by-passing
     // the full getattribute look-up.
-    pub fn get_method_or_type_error(
+    pub fn get_method_or_type_error<F>(
         &self,
         obj: PyObjectRef,
         method_name: &str,
-        err_msg: String,
-    ) -> PyResult {
+        err_msg: F,
+    ) -> PyResult
+    where
+        F: FnOnce() -> String,
+    {
         let cls = obj.class();
         match objtype::class_get_attr(&cls, method_name) {
             Some(method) => self.call_get_descriptor(method, obj.clone()),
-            None => Err(self.new_type_error(err_msg)),
+            None => Err(self.new_type_error(err_msg())),
         }
     }
 
