vm/src/stdlib/functools.rs (1)

247-247: Consider iterating directly over the keywords without cloning.

Cloning the entire dictionary here is unnecessary since you're already holding a read lock. You can iterate directly over the reference to improve performance.

Apply this diff to avoid the unnecessary clone:

-            for (key, value) in inner.keywords.clone() {
+            for (key, value) in &*inner.keywords {

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

vm/src/stdlib/functools.rs (3)

103-138: State restoration has robust validation but consider simplifying tuple handling.

The validation logic is thorough, checking tuple length, callable validity, and type correctness. However, the tuple conversion logic for handling subclasses could be simplified.

Consider using a helper function for tuple conversion to reduce code duplication:

+            fn ensure_base_tuple(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<PyTuple>> {
+                match obj.clone().downcast::<PyTuple>() {
+                    Ok(tuple) if tuple.class().is(vm.ctx.types.tuple_type) => Ok(tuple),
+                    Ok(_) | Err(_) => {
+                        let elements: Vec<PyObjectRef> = obj.try_to_value(vm)?;
+                        Ok(vm.ctx.new_tuple(elements))
+                    }
+                }
+            }
+
-            // Always convert to base tuple, even if it's a subclass
-            let args_tuple = match args.clone().downcast::<PyTuple>() {
-                Ok(tuple) if tuple.class().is(vm.ctx.types.tuple_type) => tuple,
-                _ => {
-                    // It's a tuple subclass, convert to base tuple
-                    let elements: Vec<PyObjectRef> = args.try_to_value(vm)?;
-                    vm.ctx.new_tuple(elements)
-                }
-            };
+            let args_tuple = ensure_base_tuple(args, vm)?;

---

265-323: Representation implementation is comprehensive but could be optimized.

The representation logic handles recursion correctly and provides appropriate formatting. However, the qualified name logic could be simplified and the string handling could be more efficient.

Consider simplifying the qualified name logic and using more efficient string operations:

                // Check if this is a subclass by comparing with the base partial type
-                let is_subclass = !zelf.class().is(PyPartial::class(&vm.ctx));
-
-                let qualified_name = if !is_subclass {
+                let qualified_name = if zelf.class().is(PyPartial::class(&vm.ctx)) {
                    // For the base partial class, always use functools.partial
                    "functools.partial".to_string()
                } else {
                    // For subclasses, check if they're defined in __main__ or test modules
                    match module.downcast::<crate::builtins::PyStr>() {
                        Ok(module_str) => {
                            let module_name = module_str.as_str();
                            match module_name {
-                                "builtins" | "" | "__main__" => class_name.to_string(),
+                                "builtins" | "" | "__main__" => class_name.to_owned(),
                                name if name.starts_with("test.") || name == "test" => {
-                                    // For test modules, just use the class name without module prefix
-                                    class_name.to_string()
+                                    class_name.to_owned()
                                }
                                _ => format!("{}.{}", module_name, class_name),
                            }
                        }
-                        Err(_) => class_name.to_string(),
+                        Err(_) => class_name.to_owned(),
                    }
                };

---

275-289: Argument formatting logic could be more robust.

The representation of arguments and keywords is generally correct, but the string conversion for non-string keys could be handled more defensively.

Consider adding error handling for the string conversion:

                for (key, value) in inner.keywords.clone() {
                    // For string keys, use them directly without quotes
                    let key_part = if let Ok(s) = key.clone().downcast::<crate::builtins::PyStr>() {
                        s.as_str().to_owned()
                    } else {
                        // For non-string keys, convert to string using __str__
-                        key.str(vm)?.as_str().to_owned()
+                        match key.str(vm) {
+                            Ok(s) => s.as_str().to_owned(),
+                            Err(_) => "<unprintable key>".to_owned(),
+                        }
                    };
-                    let value_str = value.repr(vm)?;
+                    let value_str = value.repr(vm).unwrap_or_else(|_| vm.ctx.new_str("<unprintable>"));
                    parts.push(format!("{}={}", key_part, value_str.as_str()));
                }

This prevents representation failures from propagating and provides more user-friendly output.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro