x

Author: youknowone

crates/codegen/src/compile.rs

@@ -4843,6 +4843,10 @@ impl Compiler {
 
         if is_async {
             emit!(self, Instruction::EndAsyncFor);
+        } else {
+            // CPython 3.14: FOR_ITER no longer pops iterator on exhaustion
+            // Pop the iterator after loop ends
+            emit!(self, Instruction::PopTop);
         }
         self.compile_statements(orelse)?;
 
@@ -7222,6 +7226,9 @@ impl Compiler {
             if is_async {
                 emit!(self, Instruction::EndAsyncFor);
                 emit!(self, Instruction::PopTop);
+            } else {
+                // CPython 3.14: FOR_ITER no longer pops iterator on exhaustion
+                emit!(self, Instruction::PopTop);
             }
         }
 

crates/compiler-core/src/bytecode/instruction.rs

@@ -582,11 +582,10 @@ impl InstructionMetadata for Instruction {
             Self::FormatSimple => 0,
             Self::FormatWithSpec => -1,
             Self::ForIter { .. } => {
-                if jump {
-                    -1
-                } else {
-                    1
-                }
+                // CPython 3.14: FOR_ITER no longer pops iterator on exhaustion
+                // jump=False: push next value (+1)
+                // jump=True: iterator stays on stack, no change (0)
+                if jump { 0 } else { 1 }
             }
             Self::IsOp(_) => -1,
             Self::ContainsOp(_) => -1,

crates/vm/src/frame.rs

@@ -931,6 +931,48 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
+            Instruction::DictMerge { index } => {
+                let source = self.pop_value();
+                let idx = index.get(arg);
+
+                // Get the dict to merge into (same logic as DICT_UPDATE)
+                let dict_ref = if idx <= 1 {
+                    self.top_value()
+                } else {
+                    self.nth_value(idx - 1)
+                };
+
+                let dict: &Py<PyDict> = unsafe { dict_ref.downcast_unchecked_ref() };
+
+                // Check if source is a mapping
+                if vm
+                    .get_method(source.clone(), vm.ctx.intern_str("keys"))
+                    .is_none()
+                {
+                    return Err(vm.new_type_error(format!(
+                        "'{}' object is not a mapping",
+                        source.class().name()
+                    )));
+                }
+
+                // Check for duplicate keys
+                let keys_iter = vm.call_method(&source, "keys", ())?;
+                for key in keys_iter.try_to_value::<Vec<PyObjectRef>>(vm)? {
+                    if key.downcast_ref::<PyStr>().is_none() {
+                        return Err(vm.new_type_error("keywords must be strings".to_owned()));
+                    }
+                    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)?;
+                }
+                Ok(None)
+            }
             Instruction::EndAsyncFor => {
                 // END_ASYNC_FOR pops (awaitable, exc) from stack
                 // Stack: [awaitable, exc] -> []
@@ -2379,15 +2421,13 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Ok(PyIterReturn::StopIteration(_)) => {
-                // Pop iterator from stack:
-                self.pop_value();
-
-                // End of for loop
+                // CPython 3.14: Do NOT pop iterator here
+                // POP_ITER instruction will handle cleanup after the loop
                 self.jump(target);
                 Ok(None)
             }
             Err(next_error) => {
-                // Pop iterator from stack:
+                // On error, pop iterator and propagate
                 self.pop_value();
                 Err(next_error)
             }