crates/vm/src/frame.rs (2)

941-958: Consider using lazy iteration over keys instead of collecting into Vec.

The current implementation collects all keys into a Vec before iterating, which allocates memory proportional to the source dict size. This could be inefficient for large mappings and doesn't match CPython's lazy iteration behavior.

Consider using the iterator protocol directly:

♻️ Suggested refactor using lazy iteration

-                // Get keys from source and check for duplicates
-                let keys_iter = vm.call_method(&source, "keys", ())?;
-                for key in keys_iter.try_to_value::<Vec<PyObjectRef>>(vm)? {
+                // Get keys from source and check for duplicates
+                let keys_obj = vm.call_method(&source, "keys", ())?;
+                let keys_iter = keys_obj.get_iter(vm)?;
+                while let PyIterReturn::Return(key) = keys_iter.next(vm)? {
                     // Check if keyword argument is a string
                     if key.downcast_ref::<PyStr>().is_none() {
                         return Err(vm.new_type_error("keywords must be strings".to_owned()));
                     }
                     // Check for duplicate keyword arguments
                     if dict.contains_key(&*key, vm) {
                         let key_repr = key.repr(vm)?;
                         return Err(vm.new_type_error(format!(
                             "got multiple values for keyword argument {}",
                             key_repr.as_str()
                         )));
                     }
                     let value = vm.call_method(&source, "__getitem__", (key.clone(),))?;
                     dict.set_item(&*key, value, vm)?;
                 }

---

1594-1607: Consider using PySet's update_internal method for consistency with ListExtend.

While ListExtend delegates to list.extend(), this handler manually iterates and adds items. PySet has an update_internal() method that takes a single iterable and would provide the same consistency pattern: replace the manual iteration with set.update_internal(iterable, vm)?;.

crates/codegen/src/compile.rs (3)

539-570: Fix LIST_EXTEND/SET_UPDATE stack target (collection is on TOS).

gather_elements leaves tuple chunks on the stack, then BUILD_LIST/BUILD_SET pushes the collection above them. LIST_EXTEND/SET_UPDATE expects the collection below the iterable on the stack, so this order can target a tuple instead of the list/set and fail at runtime. Please reorder stack construction or adjust the index/depth to match opcode expectations.

---

4436-4448: Fix LIST_EXTEND stack target for starred bases.

This sequence builds the list on TOS above tuple chunks, but LIST_EXTEND expects the list below the iterable. That can mis-target the tuple and trigger unsafe casts. Please reorder or adjust index depth as in the earlier unpacking path.

---

6994-7004: *Fix LIST_EXTEND stack target when building args tuple.

Here the list is pushed on top of tuple chunks, but LIST_EXTEND expects the list below the iterable. This can mis-target a tuple at runtime. Please reorder the stack or adjust the depth/index so the list is below the iterable.