Remove redundant CPython-referencing comments

youknowone · youknowone · commit b28fc61a39a0 · 2026-03-01T13:11:42.000+09:00
Clean up comments that unnecessarily mention CPython per project
convention. Replace with concise descriptions of the behavior itself.
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -2374,16 +2374,14 @@ impl Compiler {
                 }
             }
             ast::Stmt::Break(_) => {
-                // Match CPython line-tracing behavior (codegen_break emits NOP).
-                emit!(self, Instruction::Nop);
+                emit!(self, Instruction::Nop); // NOP for line tracing
                 // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
                 self.compile_break_continue(statement.range(), true)?;
                 let dead = self.new_block();
                 self.switch_to_block(dead);
             }
             ast::Stmt::Continue(_) => {
-                // Match CPython line-tracing behavior (codegen_continue emits NOP).
-                emit!(self, Instruction::Nop);
+                emit!(self, Instruction::Nop); // NOP for line tracing
                 // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
                 self.compile_break_continue(statement.range(), false)?;
                 let dead = self.new_block();
@@ -2456,8 +2454,7 @@ impl Compiler {
                 }
             }
             ast::Stmt::Pass(_) => {
-                // Match CPython line-tracing behavior (Pass_kind emits NOP).
-                emit!(self, Instruction::Nop);
+                emit!(self, Instruction::Nop); // NOP for line tracing
             }
             ast::Stmt::TypeAlias(ast::StmtTypeAlias {
                 name,
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
@@ -255,8 +255,8 @@ impl CodeInfo {
 
         // Convert pseudo ops and remove resulting NOPs (keep line-marker NOPs)
         convert_pseudo_ops(&mut blocks, varname_cache.len() as u32);
-        // Remove redundant NOPs (CPython basicblock_remove_redundant_nops):
-        // keep line-marker NOPs only when they are needed to preserve tracing.
+        // Remove redundant NOPs, keeping line-marker NOPs only when
+        // they are needed to preserve tracing.
         let mut block_order = Vec::new();
         let mut current = BlockIdx(0);
         while current != BlockIdx::NULL {
@@ -283,9 +283,12 @@ impl CodeInfo {
                     }
                     // Remove if the next instruction has same line or no line.
                     else if src < src_instructions.len() - 1 {
-                        let next_lineno = src_instructions[src + 1]
-                            .lineno_override
-                            .unwrap_or_else(|| src_instructions[src + 1].location.line.get() as i32);
+                        let next_lineno =
+                            src_instructions[src + 1]
+                                .lineno_override
+                                .unwrap_or_else(|| {
+                                    src_instructions[src + 1].location.line.get() as i32
+                                });
                         if next_lineno == lineno {
                             remove = true;
                         } else if next_lineno < 0 {
@@ -344,7 +347,6 @@ impl CodeInfo {
         // This is the index into the final instructions array, including EXTENDED_ARG and CACHE
         let mut block_to_index = vec![0u32; blocks.len()];
         // The offset (in code units) of END_SEND from SEND in the yield-from sequence.
-        // Matches CPython's END_SEND_OFFSET in Python/assemble.c.
         const END_SEND_OFFSET: u32 = 5;
         loop {
             let mut num_instructions = 0;
@@ -373,9 +375,8 @@ impl CodeInfo {
                     let mut op = info.instr.expect_real();
                     let old_arg_size = info.arg.instr_size();
                     let old_cache_entries = info.cache_entries;
-                    // Keep offsets fixed within this pass, like CPython's
-                    // resolve_jump_offsets(): changes in jump arg/cache sizes only
-                    // take effect in the next pass.
+                    // Keep offsets fixed within this pass: changes in jump
+                    // arg/cache sizes only take effect in the next iteration.
                     let offset_after = current_offset + old_arg_size as u32 + old_cache_entries;
 
                     if target != BlockIdx::NULL {
@@ -448,7 +449,6 @@ impl CodeInfo {
                     };
                     linetable_locations.extend(core::iter::repeat_n(lt_loc, info.arg.instr_size()));
                     // CACHE entries inherit parent instruction's location
-                    // (matches CPython assemble_location_info: instr_size includes caches)
                     if cache_count > 0 {
                         linetable_locations.extend(core::iter::repeat_n(lt_loc, cache_count));
                     }
@@ -702,7 +702,6 @@ impl CodeInfo {
         }
     }
 
-    /// CPython flowgraph.c:
     /// LOAD_GLOBAL <even> + PUSH_NULL -> LOAD_GLOBAL <odd>, NOP
     fn optimize_load_global_push_null(&mut self) {
         for block in &mut self.blocks {
@@ -1547,8 +1546,7 @@ fn normalize_jumps(blocks: &mut [Block]) {
         }
     }
 
-    // Resolve JUMP/JUMP_NO_INTERRUPT pseudo instructions before offset fixpoint,
-    // matching CPython's resolve_unconditional_jumps().
+    // Resolve JUMP/JUMP_NO_INTERRUPT pseudo instructions before offset fixpoint.
     let mut block_order = vec![0u32; blocks.len()];
     for (pos, &block_idx) in visit_order.iter().enumerate() {
         block_order[block_idx.idx()] = pos as u32;
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
@@ -1198,7 +1198,7 @@ impl InstructionMetadata for Instruction {
             Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
             Self::BuildTemplate => w!(BUILD_TEMPLATE),
             Self::BuildInterpolation { oparg } => w!(BUILD_INTERPOLATION, oparg),
-            _ => write!(f, "{self:?}"),
+            _ => w!(RUSTPYTHON_PLACEHOLDER),
         }
     }
 }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -2651,7 +2651,6 @@ impl ExecutingFrame<'_> {
             }
             Instruction::InstrumentedJumpForward => {
                 let src_offset = (self.lasti() - 1) * 2;
-                // JumpForward: 0 caches, forward
                 let target_idx = self.lasti() + u32::from(arg);
                 let target = bytecode::Label(target_idx);
                 self.jump(target);
@@ -2662,7 +2661,6 @@ impl ExecutingFrame<'_> {
             }
             Instruction::InstrumentedJumpBackward => {
                 let src_offset = (self.lasti() - 1) * 2;
-                // JumpBackward: 1 cache, backward
                 let target_idx = self.lasti() + 1 - u32::from(arg);
                 let target = bytecode::Label(target_idx);
                 self.jump(target);
@@ -2673,7 +2671,6 @@ impl ExecutingFrame<'_> {
             }
             Instruction::InstrumentedForIter => {
                 let src_offset = (self.lasti() - 1) * 2;
-                // ForIter: 1 cache, forward relative
                 let target = bytecode::Label(self.lasti() + 1 + u32::from(arg));
                 let continued = self.execute_for_iter(vm, target)?;
                 if continued {
@@ -2720,7 +2717,6 @@ impl ExecutingFrame<'_> {
             }
             Instruction::InstrumentedPopJumpIfTrue => {
                 let src_offset = (self.lasti() - 1) * 2;
-                // PopJumpIfTrue: 1 cache, forward
                 let target_idx = self.lasti() + 1 + u32::from(arg);
                 let obj = self.pop_value();
                 let value = obj.try_to_bool(vm)?;

Original file line number	Diff line number	Diff line change
`@@ -2374,16 +2374,14 @@ impl Compiler {`
`2374`	`2374`	`}`
`2375`	`2375`	`}`
`2376`	`2376`	`ast::Stmt::Break(_) => {`
`2377`		`- // Match CPython line-tracing behavior (codegen_break emits NOP).`
`2378`		`- emit!(self, Instruction::Nop);`
	`2377`	`+ emit!(self, Instruction::Nop); // NOP for line tracing`
`2379`	`2378`	`// Unwind fblock stack until we find a loop, emitting cleanup for each fblock`
`2380`	`2379`	`self.compile_break_continue(statement.range(), true)?;`
`2381`	`2380`	`let dead = self.new_block();`
`2382`	`2381`	`self.switch_to_block(dead);`
`2383`	`2382`	`}`
`2384`	`2383`	`ast::Stmt::Continue(_) => {`
`2385`		`- // Match CPython line-tracing behavior (codegen_continue emits NOP).`
`2386`		`- emit!(self, Instruction::Nop);`
	`2384`	`+ emit!(self, Instruction::Nop); // NOP for line tracing`
`2387`	`2385`	`// Unwind fblock stack until we find a loop, emitting cleanup for each fblock`
`2388`	`2386`	`self.compile_break_continue(statement.range(), false)?;`
`2389`	`2387`	`let dead = self.new_block();`
`@@ -2456,8 +2454,7 @@ impl Compiler {`
`2456`	`2454`	`}`
`2457`	`2455`	`}`
`2458`	`2456`	`ast::Stmt::Pass(_) => {`
`2459`		`- // Match CPython line-tracing behavior (Pass_kind emits NOP).`
`2460`		`- emit!(self, Instruction::Nop);`
	`2457`	`+ emit!(self, Instruction::Nop); // NOP for line tracing`
`2461`	`2458`	`}`
`2462`	`2459`	`ast::Stmt::TypeAlias(ast::StmtTypeAlias {`
`2463`	`2460`	`name,`
Original file line number	Diff line number	Diff line change
`@@ -1198,7 +1198,7 @@ impl InstructionMetadata for Instruction {`
`1198`	`1198`	`Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),`
`1199`	`1199`	`Self::BuildTemplate => w!(BUILD_TEMPLATE),`
`1200`	`1200`	`Self::BuildInterpolation { oparg } => w!(BUILD_INTERPOLATION, oparg),`
`1201`		`- _ => write!(f, "{self:?}"),`
	`1201`	`+ _ => w!(RUSTPYTHON_PLACEHOLDER),`
`1202`	`1202`	`}`
`1203`	`1203`	`}`
`1204`	`1204`	`}`