GeezerVison

 def f(kwonlyargs, kwonlydefaults, arg2value):
+def f(kwonlyargs, kw_only_defaults, arg2value):
     missing = 0
     for kwarg in kwonlyargs:
         if kwarg not in arg2value:
-            if kwonlydefaults and kwarg in kwonlydefaults:
-                arg2value[kwarg] = kwonlydefaults[kwarg]
+            if kw_only_defaults and kwarg in kw_only_defaults:
+                arg2value[kwarg] = kw_only_defaults[kwarg]
             else:
                 missing += 1

Verify each finding against the current code and only fix it if needed.

In `@crates/codegen/src/compile.rs` around lines 11158 - 11163, Rename the
misspelled identifier kwonlydefaults in the test fixture to a cspell-friendly
name (e.g., kw_only_defaults) by updating the parameter name in the function f
signature and every use inside the function body (references to kwonlydefaults
and checks like "if kwonlydefaults and kwarg in kwonlydefaults" should use the
new name); ensure all other test fixtures or assertions that reference this
parameter are updated consistently (function f, parameters kwonlyargs and
arg2value, and any access/assignment to the defaults mapping).

-            let target = ins.target;
+            let target = next_nonempty_block(blocks, ins.target);
             if target == BlockIdx::NULL {
                 continue;
             }

Verify each finding against the current code and only fix it if needed.

In `@crates/codegen/src/ir.rs` around lines 2737 - 2763, The code inspects the
target block directly (blocks[target.idx()]) which can be an empty placeholder
and miss trampoline chains; instead, before checking the target's first non-NOP
instruction, resolve the real target by threading through empty blocks using
next_nonempty_block (i.e. call next_nonempty_block(blocks, target) and update
target to that returned BlockIdx, skipping if it becomes BlockIdx::NULL) so the
subsequent logic that computes target_jump/target_ins operates on the first
non-empty block; retain existing checks for include_conditional,
is_conditional_jump, and other conditions.

         let new_idx = BlockIdx(blocks.len() as u32);
         let mut new_block = blocks[target.idx()].clone();
+        let downstream = new_block
+            .instructions
+            .last()
+            .filter(|ins| ins.instr.is_unconditional_jump() && ins.target != BlockIdx::NULL)
+            .map(|ins| next_nonempty_block(blocks, ins.target));
         propagate_locations_in_block(&mut new_block, last.location, last.end_location);
         let old_next = blocks[current.idx()].next;
         new_block.next = old_next;
         blocks.push(new_block);
         blocks[current.idx()].next = new_idx;

         let last_mut = blocks[current.idx()].instructions.last_mut().unwrap();
         last_mut.target = new_idx;
         predecessors[target.idx()] -= 1;
         predecessors.push(1);
+        if let Some(downstream) = downstream.filter(|idx| *idx != BlockIdx::NULL) {
+            predecessors[downstream.idx()] += 1;
+        }

Verify each finding against the current code and only fix it if needed.

In `@crates/codegen/src/ir.rs` around lines 3551 - 3562, When cloning the
jump-only block you adjust predecessors for the trampoline itself but forget to
increment the predecessor count for the trampoline's downstream target
(old_next), causing stale fan-in; after you set new_block.next = old_next, push
the new predecessor for the cloned block (predecessors.push(1)), also increment
predecessors[old_next.idx()] by one (with a bounds/existence check if necessary)
so the successor's incoming edge count reflects the new clone — reference
symbols: new_block, old_next, new_idx, predecessors, target, blocks,
propagate_locations_in_block.

#!/bin/bash
python - <<'PY'
import dis
import types

src = """
def f(xs):
    for x in xs:
        if x:
            pass
"""
mod = compile(src, "<mem>", "exec")
fn = next(c for c in mod.co_consts if isinstance(c, types.CodeType))
insts = list(dis.get_instructions(fn))

print("separate CACHE items:", [i.opname for i in insts if i.opname == "CACHE"])
print("metadata fields:", [name for name in ("start_offset", "cache_offset", "end_offset", "cache_info") if hasattr(insts[0], name)])
print("any cache_info present:", any(getattr(i, "cache_info", None) for i in insts))
PY

Verify each finding against the current code and only fix it if needed.

In `@scripts/dis_dump.py` around lines 182 - 193, The current loop that builds
filtered and offset_to_idx (iterating over raw and using normalized_idx with
_SUPER_DECOMPOSE and _OPNAME_NORMALIZE) produces a logical-instruction index
map, not a raw-bytecode-slot map; update the loop that builds
filtered/offset_to_idx to account for cache/prefix slots by inspecting each
instruction's cache_info (or otherwise using a low-level bytecode API) so
offset_to_idx maps actual raw bytecode slots used by compare_bytecode.py, e.g.,
when inst.cache_info indicates extra cache entries increment normalized_idx and
reserve corresponding slot indices before mapping inst.offset; modify the code
near the filtered/offset_to_idx construction (the loop over raw, SKIP_OPS
handling, and uses of _SUPER_DECOMPOSE/_OPNAME_NORMALIZE) to synthesize those
cache/prefix slots or switch to a bytecode-level API.