remove useless refcount

Author: youknowone

src/lib.rs

@@ -106,7 +106,6 @@ fn setup_main_module(vm: &VirtualMachine) -> PyResult<Scope> {
         .expect("Failed to initialize __main__.__annotations__");
 
     vm.sys_module
-        .clone()
         .get_attr("modules", vm)?
         .set_item("__main__", main_module, vm)?;
 

src/shell.rs

@@ -105,7 +105,6 @@ pub fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
         let prompt_name = if continuing { "ps2" } else { "ps1" };
         let prompt = vm
             .sys_module
-            .clone()
             .get_attr(prompt_name, vm)
             .and_then(|prompt| prompt.str(vm));
         let prompt = match prompt {

vm/src/builtins/union.rs

@@ -278,7 +278,7 @@ impl GetAttr for PyUnion {
                 return zelf.as_object().generic_getattr(attr, vm);
             }
         }
-        zelf.as_object().to_pyobject(vm).get_attr(attr, vm)
+        zelf.as_object().get_attr(attr, vm)
     }
 }
 

vm/src/codecs.rs

@@ -359,9 +359,9 @@ fn normalize_encoding_name(encoding: &str) -> Cow<'_, str> {
 
 // TODO: exceptions with custom payloads
 fn extract_unicode_error_range(err: &PyObject, vm: &VirtualMachine) -> PyResult<Range<usize>> {
-    let start = err.to_owned().get_attr("start", vm)?;
+    let start = err.get_attr("start", vm)?;
     let start = start.try_into_value(vm)?;
-    let end = err.to_owned().get_attr("end", vm)?;
+    let end = err.get_attr("end", vm)?;
     let end = end.try_into_value(vm)?;
     Ok(Range { start, end })
 }

vm/src/frame.rs

@@ -1155,11 +1155,7 @@ impl ExecutingFrame<'_> {
             .map_err(|_| err())?;
         let mod_name = mod_name.downcast::<PyStr>().map_err(|_| err())?;
         let full_mod_name = format!("{mod_name}.{name}");
-        let sys_modules = vm
-            .sys_module
-            .clone()
-            .get_attr("modules", vm)
-            .map_err(|_| err())?;
+        let sys_modules = vm.sys_module.get_attr("modules", vm).map_err(|_| err())?;
         sys_modules.get_item(&full_mod_name, vm).map_err(|_| err())
     }
 
@@ -1459,7 +1455,7 @@ impl ExecutingFrame<'_> {
             // FIXME: turn return type to PyResult<PyIterReturn> then ExecutionResult will be simplified
             None if vm.is_none(&val) => PyIter::new(gen).next(vm),
             None => {
-                let meth = gen.to_owned().get_attr("send", vm)?;
+                let meth = gen.get_attr("send", vm)?;
                 PyIterReturn::from_pyresult(meth.call((val,), vm), vm)
             }
         }
@@ -1744,7 +1740,6 @@ impl ExecutingFrame<'_> {
 
         let displayhook = vm
             .sys_module
-            .clone()
             .get_attr("displayhook", vm)
             .map_err(|_| vm.new_runtime_error("lost sys.displayhook".to_owned()))?;
         displayhook.call((expr,), vm)?;

vm/src/protocol/object.rs

@@ -357,16 +357,14 @@ impl PyObject {
     where
         F: Fn() -> String,
     {
-        cls.to_owned()
-            .get_attr(identifier!(vm, __bases__), vm)
-            .map_err(|e| {
-                // Only mask AttributeErrors.
-                if e.class().is(vm.ctx.exceptions.attribute_error) {
-                    vm.new_type_error(msg())
-                } else {
-                    e
-                }
-            })
+        cls.get_attr(identifier!(vm, __bases__), vm).map_err(|e| {
+            // Only mask AttributeErrors.
+            if e.class().is(vm.ctx.exceptions.attribute_error) {
+                vm.new_type_error(msg())
+            } else {
+                e
+            }
+        })
     }
 
     fn abstract_issubclass(&self, cls: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {

vm/src/stdlib/io.rs

@@ -146,7 +146,7 @@ mod _io {
     }
 
     fn ensure_unclosed(file: &PyObject, msg: &str, vm: &VirtualMachine) -> PyResult<()> {
-        if file.to_owned().get_attr("closed", vm)?.try_to_bool(vm)? {
+        if file.get_attr("closed", vm)?.try_to_bool(vm)? {
             Err(vm.new_value_error(msg.to_owned()))
         } else {
             Ok(())
@@ -324,7 +324,7 @@ mod _io {
     }
 
     fn file_closed(file: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
-        file.to_owned().get_attr("closed", vm)?.try_to_bool(vm)
+        file.get_attr("closed", vm)?.try_to_bool(vm)
     }
     fn check_closed(file: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
         if file_closed(file, vm)? {
@@ -1346,7 +1346,7 @@ mod _io {
     }
 
     pub fn repr_fileobj_name(obj: &PyObject, vm: &VirtualMachine) -> PyResult<Option<PyStrRef>> {
-        let name = match obj.to_owned().get_attr("name", vm) {
+        let name = match obj.get_attr("name", vm) {
             Ok(name) => Some(name),
             Err(e)
                 if e.fast_isinstance(vm.ctx.exceptions.attribute_error)
@@ -1506,24 +1506,15 @@ mod _io {
         }
         #[pygetset]
         fn closed(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?
-                .check_init(vm)?
-                .to_owned()
-                .get_attr("closed", vm)
+            self.lock(vm)?.check_init(vm)?.get_attr("closed", vm)
         }
         #[pygetset]
         fn name(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?
-                .check_init(vm)?
-                .to_owned()
-                .get_attr("name", vm)
+            self.lock(vm)?.check_init(vm)?.get_attr("name", vm)
         }
         #[pygetset]
         fn mode(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?
-                .check_init(vm)?
-                .to_owned()
-                .get_attr("mode", vm)
+            self.lock(vm)?.check_init(vm)?.get_attr("mode", vm)
         }
         #[pymethod]
         fn fileno(&self, vm: &VirtualMachine) -> PyResult {

vm/src/stdlib/os.rs

@@ -1803,7 +1803,7 @@ pub fn extend_module(vm: &VirtualMachine, module: &PyObject) {
     let supports_dir_fd = PySet::default().into_ref(&vm.ctx);
     let supports_follow_symlinks = PySet::default().into_ref(&vm.ctx);
     for support in support_funcs {
-        let func_obj = module.to_owned().get_attr(support.name, vm).unwrap();
+        let func_obj = module.get_attr(support.name, vm).unwrap();
         if support.fd.unwrap_or(false) {
             supports_fd.clone().add(func_obj.clone(), vm).unwrap();
         }

vm/src/stdlib/signal.rs

@@ -100,7 +100,6 @@ pub(crate) mod _signal {
         }
 
         let int_handler = module
-            .clone()
             .get_attr("default_int_handler", vm)
             .expect("_signal does not have this attr?");
         if !vm.state.settings.no_sig_int {

vm/src/stdlib/sys.rs

@@ -953,19 +953,16 @@ impl PyStderr<'_> {
 
 pub fn get_stdin(vm: &VirtualMachine) -> PyResult {
     vm.sys_module
-        .clone()
         .get_attr("stdin", vm)
         .map_err(|_| vm.new_runtime_error("lost sys.stdin".to_owned()))
 }
 pub fn get_stdout(vm: &VirtualMachine) -> PyResult {
     vm.sys_module
-        .clone()
         .get_attr("stdout", vm)
         .map_err(|_| vm.new_runtime_error("lost sys.stdout".to_owned()))
 }
 pub fn get_stderr(vm: &VirtualMachine) -> PyResult {
     vm.sys_module
-        .clone()
         .get_attr("stderr", vm)
         .map_err(|_| vm.new_runtime_error("lost sys.stderr".to_owned()))
 }