Merge pull request RustPython#2248 from youknowone/lease-class

youknowone · web-flow · commit 75161a63deb1 · 2020-10-10T13:38:19.000+09:00
lease_class as much as possible
diff --git a/vm/src/bytesinner.rs b/vm/src/bytesinner.rs
@@ -51,7 +51,10 @@ impl TryFromObject for PyBytesInner {
             l @ PyList => l.to_byte_inner(vm),
             obj => {
                 let iter = vm.get_method_or_type_error(obj.clone(), "__iter__", || {
-                    format!("a bytes-like object is required, not {}", obj.class())
+                    format!(
+                        "a bytes-like object is required, not '{}'",
+                        obj.lease_class().name
+                    )
                 })?;
                 let iter = PyIterable::from_method(iter);
                 Ok(PyBytesInner {
@@ -328,7 +331,7 @@ impl PyBytesInner {
         let value = vm.to_index(&object).ok_or_else(|| {
             vm.new_type_error(format!(
                 "'{}' object cannot be interpreted as an integer",
-                object.class().name
+                object.lease_class().name
             ))
         })?;
         // __index__ returned non-int type
diff --git a/vm/src/byteslike.rs b/vm/src/byteslike.rs
@@ -100,8 +100,10 @@ impl TryFromObject for PyRwBytesLike {
         match_class!(match obj {
             b @ PyByteArray => Ok(PyRwBytesLike::Bytearray(b)),
             array @ PyArray => Ok(PyRwBytesLike::Array(array)),
-            obj =>
-                Err(vm.new_type_error(format!("a buffer object is required, not {}", obj.class()))),
+            obj => Err(vm.new_type_error(format!(
+                "a buffer object is required, not '{}'",
+                obj.lease_class().name
+            ))),
         })
     }
 }
diff --git a/vm/src/format.rs b/vm/src/format.rs
@@ -906,7 +906,7 @@ fn call_object_format(
     if !objtype::isinstance(&result, &vm.ctx.types.str_type) {
         return Err(vm.new_type_error(format!(
             "__format__ must return a str, not {}",
-            &result.class().name
+            &result.lease_class().name
         )));
     }
     Ok(result)
diff --git a/vm/src/function.rs b/vm/src/function.rs
@@ -130,7 +130,7 @@ impl PyFuncArgs {
                     Ok(Some(kwarg))
                 } else {
                     let expected_ty_name = &ty.name;
-                    let actual_ty_name = &kwarg.class().name;
+                    let actual_ty_name = &kwarg.lease_class().name;
                     Err(vm.new_type_error(format!(
                         "argument of type {} is required for named parameter `{}` (got: {})",
                         expected_ty_name, key, actual_ty_name
diff --git a/vm/src/obj/objbool.rs b/vm/src/obj/objbool.rs
@@ -145,7 +145,7 @@ impl PyBool {
     #[pyslot]
     fn tp_new(zelf: PyObjectRef, x: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
         if !objtype::isinstance(&zelf, &vm.ctx.types.type_type) {
-            let actual_type = &zelf.class().name;
+            let actual_type = &zelf.lease_class().name;
             return Err(vm.new_type_error(format!(
                 "requires a 'type' object but received a '{}'",
                 actual_type
diff --git a/vm/src/obj/objcomplex.rs b/vm/src/obj/objcomplex.rs
@@ -242,7 +242,7 @@ impl PyComplex {
                 } else {
                     return Err(vm.new_type_error(format!(
                         "complex() first argument must be a string or a number, not '{}'",
-                        obj.class()
+                        obj.lease_class().name
                     )));
                 }
             }
@@ -260,7 +260,7 @@ impl PyComplex {
                 } else {
                     return Err(vm.new_type_error(format!(
                         "complex() second argument must be a number, not '{}'",
-                        obj.class()
+                        obj.lease_class().name
                     )));
                 }
             }
diff --git a/vm/src/obj/objint.rs b/vm/src/obj/objint.rs
@@ -747,15 +747,15 @@ pub(crate) fn to_int(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<BigInt>
             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
+                    obj.lease_class().name
                 )
             })?;
             let result = vm.invoke(&method, PyFuncArgs::default())?;
             return match result.payload::<PyInt>() {
                 Some(int_obj) => Ok(int_obj.borrow_value().clone()),
                 None => Err(vm.new_type_error(format!(
                     "TypeError: __int__ returned non-int (type '{}')",
-                    result.class().name
+                    result.lease_class().name
                 ))),
             };
         }
diff --git a/vm/src/obj/objlist.rs b/vm/src/obj/objlist.rs
@@ -80,7 +80,7 @@ impl PyList {
             let py_int = PyIntRef::try_from_object(vm, elem.clone()).map_err(|_| {
                 vm.new_type_error(format!(
                     "'{}' object cannot be interpreted as an integer",
-                    elem.class().name
+                    elem.lease_class().name
                 ))
             })?;
             let result = py_int
diff --git a/vm/src/obj/objobject.rs b/vm/src/obj/objobject.rs
@@ -228,7 +228,7 @@ impl PyBaseObject {
                     Ok(())
                 }
                 Err(value) => {
-                    let type_repr = &value.class().name;
+                    let type_repr = &value.lease_class().name;
                     Err(vm.new_type_error(format!(
                         "__class__ must be set to a class, not '{}' object",
                         type_repr
diff --git a/vm/src/obj/objrange.rs b/vm/src/obj/objrange.rs
@@ -414,8 +414,8 @@ impl TryFromObject for RangeIndex {
             i @ PyInt => Ok(RangeIndex::Int(i)),
             s @ PySlice => Ok(RangeIndex::Slice(s)),
             obj => Err(vm.new_type_error(format!(
-                "sequence indices be integers or slices, not {}",
-                obj.class(),
+                "sequence indices be integers or slices, not '{}'",
+                obj.lease_class().name,
             ))),
         })
     }
diff --git a/vm/src/obj/objstr.rs b/vm/src/obj/objstr.rs
@@ -201,7 +201,7 @@ impl PyStr {
                 PyStr::from(String::new()).into_ref_with_type(vm, cls.clone())?
             }
         };
-        if string.class().is(&cls) {
+        if string.lease_class().is(&cls) {
             Ok(string)
         } else {
             PyStr::from(string.borrow_value()).into_ref_with_type(vm, cls)
diff --git a/vm/src/obj/objtuple.rs b/vm/src/obj/objtuple.rs
@@ -101,9 +101,9 @@ impl PyTuple {
         vm: &VirtualMachine,
     ) -> PyArithmaticValue<PyRef<Self>> {
         let added = other.downcast::<Self>().map(|other| {
-            if other.elements.is_empty() && zelf.class().is(&vm.ctx.types.tuple_type) {
+            if other.elements.is_empty() && zelf.lease_class().is(&vm.ctx.types.tuple_type) {
                 zelf
-            } else if zelf.elements.is_empty() && other.class().is(&vm.ctx.types.tuple_type) {
+            } else if zelf.elements.is_empty() && other.lease_class().is(&vm.ctx.types.tuple_type) {
                 other
             } else {
                 let elements = zelf
diff --git a/vm/src/obj/objtype.rs b/vm/src/obj/objtype.rs
@@ -387,13 +387,13 @@ impl PyType {
 
         let mut attributes = dict.to_attributes();
         if let Some(f) = attributes.get_mut("__new__") {
-            if f.class().is(&vm.ctx.types.function_type) {
+            if f.lease_class().is(&vm.ctx.types.function_type) {
                 *f = PyStaticMethod::from(f.clone()).into_object(vm);
             }
         }
 
         if let Some(f) = attributes.get_mut("__init_subclass__") {
-            if f.class().is(&vm.ctx.types.function_type) {
+            if f.lease_class().is(&vm.ctx.types.function_type) {
                 *f = PyClassMethod::from(f.clone()).into_object(vm);
             }
         }
diff --git a/vm/src/pyobjectrc.rs b/vm/src/pyobjectrc.rs
@@ -155,7 +155,7 @@ where
                     let repr = vm.to_repr(&del_method);
                     match repr {
                         Ok(v) => println!("{}", v.to_string()),
-                        Err(_) => println!("{}", &del_method.class().name),
+                        Err(_) => println!("{}", del_method.lease_class().name),
                     }
                     let tb_module = vm.import("traceback", &[], 0).unwrap();
                     // TODO: set exc traceback
diff --git a/vm/src/stdlib/array.rs b/vm/src/stdlib/array.rs
@@ -442,14 +442,21 @@ fn f64_swap_bytes(x: f64) -> f64 {
 }
 
 fn f32_try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<f32> {
-    try_float(&obj, vm)?
-        .map(|x| x as f32)
-        .ok_or_else(|| vm.new_type_error(format!("must be real number, not {}", obj.class().name)))
+    try_float(&obj, vm)?.map(|x| x as f32).ok_or_else(|| {
+        vm.new_type_error(format!(
+            "must be real number, not {}",
+            obj.lease_class().name
+        ))
+    })
 }
 
 fn f64_try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<f64> {
-    try_float(&obj, vm)?
-        .ok_or_else(|| vm.new_type_error(format!("must be real number, not {}", obj.class().name)))
+    try_float(&obj, vm)?.ok_or_else(|| {
+        vm.new_type_error(format!(
+            "must be real number, not {}",
+            obj.lease_class().name
+        ))
+    })
 }
 
 #[pyclass(module = "array", name = "array")]
@@ -666,7 +673,7 @@ impl PyArray {
                         None => {
                             return Err(vm.new_type_error(format!(
                                 "can only assign array (not \"{}\") to array slice",
-                                obj.class().name
+                                obj.lease_class().name
                             )));
                         }
                     }
@@ -698,7 +705,7 @@ impl PyArray {
         } else {
             Err(vm.new_type_error(format!(
                 "can only append array (not \"{}\") to array",
-                other.class().name
+                other.lease_class().name
             )))
         }
     }
@@ -714,7 +721,7 @@ impl PyArray {
         } else {
             Err(vm.new_type_error(format!(
                 "can only extend array with array (not \"{}\")",
-                other.class().name
+                other.lease_class().name
             )))
         }
     }
diff --git a/vm/src/stdlib/binascii.rs b/vm/src/stdlib/binascii.rs
@@ -34,7 +34,7 @@ mod decl {
                 }
                 obj => Err(vm.new_type_error(format!(
                     "argument should be bytes, buffer or ASCII string, not '{}'",
-                    obj.class().name,
+                    obj.lease_class().name,
                 ))),
             })
         }
diff --git a/vm/src/stdlib/csv.rs b/vm/src/stdlib/csv.rs
@@ -81,7 +81,7 @@ fn into_strings(iterable: &PyIterable<PyObjectRef>, vm: &VirtualMachine) -> PyRe
                 obj => {
                     let msg = format!(
             "iterator should return strings, not {} (did you open the file in text mode?)",
-            obj.class().name
+            obj.lease_class().name
           );
                     Err(vm.new_type_error(msg))
                 }
diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs
@@ -965,7 +965,7 @@ mod decl {
     impl PyItertoolsTee {
         fn from_iter(iterable: PyObjectRef, vm: &VirtualMachine) -> PyResult {
             let it = get_iter(vm, &iterable)?;
-            if it.class().is(&PyItertoolsTee::class(vm)) {
+            if it.lease_class().is(&PyItertoolsTee::class(vm)) {
                 return vm.call_method(&it, "__copy__", PyFuncArgs::from(vec![]));
             }
             Ok(PyItertoolsTee {
diff --git a/vm/src/stdlib/operator.rs b/vm/src/stdlib/operator.rs
@@ -11,7 +11,7 @@ fn _operator_length_hint(obj: PyObjectRef, default: OptionalArg, vm: &VirtualMac
     if !objtype::isinstance(&default, &vm.ctx.types.int_type) {
         return Err(vm.new_type_error(format!(
             "'{}' type cannot be interpreted as an integer",
-            default.class().name
+            default.lease_class().name
         )));
     }
     let hint = objiter::length_hint(vm, obj)?
diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs
@@ -112,15 +112,15 @@ impl TryFromObject for PyPathLike {
         let method = vm.get_method_or_type_error(obj.clone(), "__fspath__", || {
             format!(
                 "expected str, bytes or os.PathLike object, not '{}'",
-                obj.class().name
+                obj.lease_class().name
             )
         })?;
         let result = vm.invoke(&method, PyFuncArgs::default())?;
         match1(&result)?.ok_or_else(|| {
             vm.new_type_error(format!(
                 "expected {}.__fspath__() to return str or bytes, not '{}'",
-                obj.class().name,
-                result.class().name,
+                obj.lease_class().name,
+                result.lease_class().name,
             ))
         })
     }
diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs
@@ -87,7 +87,7 @@ macro_rules! repr_lock_impl {
         format!(
             "<{} {} object at {}>",
             status,
-            $zelf.class().name,
+            $zelf.lease_class().name,
             $zelf.get_id()
         )
     }};
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -854,7 +854,7 @@ impl VirtualMachine {
     pub fn isinstance(&self, obj: &PyObjectRef, cls: &PyTypeRef) -> PyResult<bool> {
         // cpython first does an exact check on the type, although documentation doesn't state that
         // https://github.com/python/cpython/blob/a24107b04c1277e3c1105f98aff5bfa3a98b33a0/Objects/abstract.c#L2408
-        if obj.class().is(cls) {
+        if obj.lease_class().is(cls) {
             Ok(true)
         } else {
             let ret = self.call_method(cls.as_object(), "__instancecheck__", vec![obj.clone()])?;
@@ -976,7 +976,7 @@ impl VirtualMachine {
 
     pub fn extract_elements<T: TryFromObject>(&self, value: &PyObjectRef) -> PyResult<Vec<T>> {
         // Extract elements from item, if possible:
-        let cls = value.class();
+        let cls = value.lease_class();
         if cls.is(&self.ctx.types.tuple_type) {
             value
                 .payload::<PyTuple>()
@@ -1121,9 +1121,7 @@ impl VirtualMachine {
         dict: Option<PyDictRef>,
     ) -> PyResult<Option<PyObjectRef>> {
         let name = name_str.borrow_value();
-        let cls = obj.class();
-
-        let cls_attr = cls.get_attr(name);
+        let cls_attr = obj.lease_class().get_attr(name);
 
         if let Some(ref attr) = cls_attr {
             if attr.lease_class().has_attr("__set__") {
@@ -1145,7 +1143,7 @@ impl VirtualMachine {
             Ok(Some(obj_attr))
         } else if let Some(attr) = cls_attr {
             self.call_if_get_descriptor(attr, obj).map(Some)
-        } else if let Some(getter) = cls.get_attr("__getattr__") {
+        } else if let Some(getter) = obj.class().get_attr("__getattr__") {
             self.invoke(&getter, vec![obj, name_str.into_object()])
                 .map(Some)
         } else {

Original file line number	Diff line number	Diff line change
`@@ -100,8 +100,10 @@ impl TryFromObject for PyRwBytesLike {`
`100`	`100`	`match_class!(match obj {`
`101`	`101`	`b @ PyByteArray => Ok(PyRwBytesLike::Bytearray(b)),`
`102`	`102`	`array @ PyArray => Ok(PyRwBytesLike::Array(array)),`
`103`		`- obj =>`
`104`		`- Err(vm.new_type_error(format!("a buffer object is required, not {}", obj.class()))),`
	`103`	`+ obj => Err(vm.new_type_error(format!(`
	`104`	`+ "a buffer object is required, not '{}'",`
	`105`	`+ obj.lease_class().name`
	`106`	`+ ))),`
`105`	`107`	`})`
`106`	`108`	`}`
`107`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -906,7 +906,7 @@ fn call_object_format(`
`906`	`906`	`if !objtype::isinstance(&result, &vm.ctx.types.str_type) {`
`907`	`907`	`return Err(vm.new_type_error(format!(`
`908`	`908`	`"__format__ must return a str, not {}",`
`909`		`- &result.class().name`
	`909`	`+ &result.lease_class().name`
`910`	`910`	`)));`
`911`	`911`	`}`
`912`	`912`	`Ok(result)`
Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ impl PyComplex {`
`242`	`242`	`} else {`
`243`	`243`	`return Err(vm.new_type_error(format!(`
`244`	`244`	`"complex() first argument must be a string or a number, not '{}'",`
`245`		`- obj.class()`
	`245`	`+ obj.lease_class().name`
`246`	`246`	`)));`
`247`	`247`	`}`
`248`	`248`	`}`
`@@ -260,7 +260,7 @@ impl PyComplex {`
`260`	`260`	`} else {`
`261`	`261`	`return Err(vm.new_type_error(format!(`
`262`	`262`	`"complex() second argument must be a number, not '{}'",`
`263`		`- obj.class()`
	`263`	`+ obj.lease_class().name`
`264`	`264`	`)));`
`265`	`265`	`}`
`266`	`266`	`}`
Original file line number	Diff line number	Diff line change
`@@ -228,7 +228,7 @@ impl PyBaseObject {`
`228`	`228`	`Ok(())`
`229`	`229`	`}`
`230`	`230`	`Err(value) => {`
`231`		`- let type_repr = &value.class().name;`
	`231`	`+ let type_repr = &value.lease_class().name;`
`232`	`232`	`Err(vm.new_type_error(format!(`
`233`	`233`	`"__class__ must be set to a class, not '{}' object",`
`234`	`234`	`type_repr`