crates/vm/src/builtins/genericalias.rs (1)

737-766: Duplicated logic with unpack_typevartuples in typing.rs.

This TypeVarTuple unpacking logic (check downcast_ref::<TypeVarTuple>, wrap with Unpack.__getitem__) is essentially identical to unpack_typevartuples in crates/vm/src/stdlib/typing.rs (lines 469–490). Consider extracting a shared helper to avoid maintaining both copies.

Additionally, new_args (line 738) is allocated even when needs_unpack is false and the else branch returns params without using it. Move the allocation inside the if needs_unpack block.

Suggested refactor

-    // Unpack TypeVarTuples: wrap each TypeVarTuple in Unpack[...]
-    let mut new_args = Vec::with_capacity(params.len());
-    let mut needs_unpack = false;
-    for param in params.iter() {
-        if param
-            .downcast_ref::<crate::stdlib::typing::TypeVarTuple>()
-            .is_some()
-        {
-            needs_unpack = true;
-            break;
-        }
-    }
-
-    let args = if needs_unpack {
-        let unpack_cls = typing_module.get_attr("Unpack", vm)?;
-        for param in params.iter() {
-            if param
-                .downcast_ref::<crate::stdlib::typing::TypeVarTuple>()
-                .is_some()
-            {
-                let unpacked = vm.call_method(&unpack_cls, "__getitem__", (param.clone(),))?;
-                new_args.push(unpacked);
-            } else {
-                new_args.push(param.clone());
-            }
-        }
-        PyTuple::new_ref(new_args, &vm.ctx)
-    } else {
-        params
-    };
+    // Unpack TypeVarTuples: wrap each TypeVarTuple in Unpack[...]
+    let has_tvt = params
+        .iter()
+        .any(|p| p.downcast_ref::<crate::stdlib::typing::TypeVarTuple>().is_some());
+
+    let args = if has_tvt {
+        let unpack_cls = typing_module.get_attr("Unpack", vm)?;
+        let new_args: Vec<PyObjectRef> = params
+            .iter()
+            .map(|p| {
+                if p.downcast_ref::<crate::stdlib::typing::TypeVarTuple>().is_some() {
+                    vm.call_method(&unpack_cls, "__getitem__", (p.clone(),))
+                } else {
+                    Ok(p.clone())
+                }
+            })
+            .collect::<PyResult<_>>()?;
+        PyTuple::new_ref(new_args, &vm.ctx)
+    } else {
+        params
+    };

This also aligns the style with the existing unpack_typevartuples in crates/vm/src/stdlib/typing.rs (line 479–488), which uses the iterator/map/collect pattern.

crates/vm/src/stdlib/typevar.rs (1)

670-685: ParamSpec and TypeVar repr implementations are identical — consider extracting a shared helper.

The variance-prefix formatting logic (lines 674–684) is a direct copy of TypeVar's repr_str (lines 273–283). A small shared function like format_variance_prefix(name, infer_variance, covariant, contravariant) would eliminate the duplication.

crates/vm/src/builtins/genericalias.rs (1)

737-759: Eliminate duplicate TypeVarTuple-unpacking logic by reusing unpack_typevartuples.

The logic at lines 737–759 duplicates the exact same TypeVarTuple detection and wrapping pattern already implemented in crate::stdlib::typing::unpack_typevartuples() (lines 470–490). The only syntactic difference is downcast_ref::<…>().is_some() vs downcastable::<…>(), which are equivalent.

To maintain a single source of truth, make unpack_typevartuples pub(crate) in typing.rs and call it here instead:

-    let has_tvt = params
-        .iter()
-        .any(|p| p.downcast_ref::<crate::stdlib::typing::TypeVarTuple>().is_some());
-
-    let args = if has_tvt {
-        let unpack_cls = typing_module.get_attr("Unpack", vm)?;
-        let new_args: Vec<PyObjectRef> = params
-            .iter()
-            .map(|p| {
-                if p.downcast_ref::<crate::stdlib::typing::TypeVarTuple>()
-                    .is_some()
-                {
-                    vm.call_method(&unpack_cls, "__getitem__", (p.clone(),))
-                } else {
-                    Ok(p.clone())
-                }
-            })
-            .collect::<PyResult<_>>()?;
-        PyTuple::new_ref(new_args, &vm.ctx)
-    } else {
-        params
-    };
+    let args = crate::stdlib::typing::unpack_typevartuples(&params, vm)?;

crates/codegen/src/symboltable.rs (1)

1279-1322: class_name save/restore is correct for nested classes and the generic path.

One minor observation: when type_params.is_some(), line 1300 re-sets class_name to the same value already set at line 1288. This is harmless (and needed for the non-generic path), but you could guard the second set with if type_params.is_none() if you want to avoid the redundant allocation.

Optional: avoid redundant allocation when type_params is present

-                // Set class_name for mangling in class body
-                self.class_name = Some(name.to_string());
+                // Set class_name for mangling in class body (already set for generic path)
+                if type_params.is_none() {
+                    self.class_name = Some(name.to_string());
+                }

crates/vm/src/types/slot.rs (1)

536-545: Double MRO lookup for __iter__ in the non-None path.

When __iter__ exists and is not None, cls.get_attr() (line 539) performs an MRO lookup, and then vm.call_special_method() (line 544) performs a second MRO lookup for the same __iter__. This is functionally correct but redundant.

Since this wrapper is only invoked for heap types with a Python-defined __iter__, the overhead is likely negligible in practice. Consider caching the result if profiling ever shows this as a concern.

♻️ Optional: reuse the looked-up attribute to avoid the second MRO walk

 fn iter_wrapper(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     // slot_tp_iter: if __iter__ is None, the type is explicitly not iterable
     let cls = zelf.class();
     let iter_attr = cls.get_attr(identifier!(vm, __iter__));
     match iter_attr {
         Some(attr) if vm.is_none(&attr) => {
             Err(vm.new_type_error(format!("'{}' object is not iterable", cls.name())))
         }
-        _ => vm.call_special_method(&zelf, identifier!(vm, __iter__), ()),
+        Some(attr) => attr.call((zelf,), vm),
+        None => vm.call_special_method(&zelf, identifier!(vm, __iter__), ()),
     }
 }