GeezerVison

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/codegen/src/ir.rs`:
- Around line 9229-9233: fast_scan_many_locals currently treats every local
index >=64 as unknown, causing parameters beyond index 63 to be misclassified;
pass the function's parameter count (nparams) into fast_scan_many_locals (or
otherwise make the helper aware of nparams) and mark any local index < nparams
as initialized/parameter so they are not converted to LOAD_FAST_CHECK or split
by LOAD_FAST_LOAD_FAST; update the call sites (and the fast path logic inside
fast_scan_many_locals and its use of merged_cell_local) to exempt indices <
nparams from the unknown high-index handling (also apply the same change to the
related code block around lines 9344-9402 that duplicates this fast path).
- Around line 10627-10672: The helpers opposite_short_circuit_target and
same_short_circuit_target must verify the entire short-circuit stub shape, not
just the first two ops and the trailing conditional jump; modify both functions
to (1) ensure the first instruction is exactly Instruction::Copy with
i.get(first.arg) == 1 and the second is exactly Instruction::ToBool, (2) iterate
over the instructions between index 2 and cond_idx (exclusive) and require each
instruction's real() to be either None or one of the allowed marker ops (e.g.
Instruction::Nop or Instruction::NotTaken) — reject the block if any other real
instruction appears, and (3) only then perform the existing matches against
block.instructions[cond_idx].instr.real(); apply the same stricter validation in
both opposite_short_circuit_target and same_short_circuit_target so
jump_threading_impl cannot skip real instructions when threading.

---

Nitpick comments:
In `@crates/codegen/src/symboltable.rs`:
- Around line 1061-1070: Add a short doc comment above is_function_like_scope
explaining that its set (Function, AsyncFunction, Lambda, Comprehension,
Annotation) intentionally differs from the predicate
compile.rs::is_function_like (which uses Function, AsyncFunction, Annotation,
TypeParams); note that is_function_like_scope mirrors CPython's analyze_cells
semantics in symtable.c while the compile.rs variant is used for guarding
CodeFlags, so readers should not conflate the two. Include references to both
symbols (is_function_like_scope and compile.rs::is_function_like) in the comment
for clarity.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/codegen/src/ir.rs`:
- Around line 4648-4680: The current block_has_simple_scope_exit() treats
certain already-lowered fast-local superinstructions as non-simple and thus
causes leading_bool_guard_has_scope_exit_successor() to prematurely stop
segments; update the match arm that currently allows LoadFastLoadFast,
LoadFastBorrowLoadFastBorrow, etc., to also accept the lowered opcodes
StoreFastLoadFast, StoreFastStoreFast and LoadFastCheck (i.e., add
Instruction::StoreFastLoadFast { .. }, Instruction::StoreFastStoreFast { .. },
and Instruction::LoadFastCheck { .. } to the permissive Some(...) pattern) so
those successors are considered simple scope-exit blocks and the borrow deopt
path is not skipped.
- Around line 2655-2671: The check that sets
preserve_block_start_no_location_nop runs before the trailing conditional jump
is converted to an unconditional jump, so patterns like "LOAD_CONST True;
POP_JUMP_IF_TRUE <self>" are not recognized; move or re-run the
preserves_pure_self_loop_anchor detection after the jump-rewrite phase (i.e.,
after the code that turns the trailing conditional into a plain jump), or adjust
the predicate to treat the specific conditional that will be rewritten as
unconditional (use info.instr / info.instr.real() and is_unconditional_jump or
detect POP_JUMP_IF_TRUE with a constant true target) so that set_to_nop and the
preserves_pure_self_loop_anchor logic see the post-rewrite form before deciding
to set preserve_block_start_no_location_nop.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/codegen/src/compile.rs`:
- Around line 611-619: The predicate statements_end_with_with_cleanup_scope_exit
only matches ast::Stmt::With and therefore misses nested async-with nodes;
update its match arm to handle ast::Stmt::AsyncWith (likely
ast::Stmt::AsyncWith(ast::StmtAsyncWith { body, .. })) the same way as
ast::Stmt::With so it recurses into async with bodies and calls
Self::statements_end_with_scope_exit and
Self::statements_end_with_with_cleanup_scope_exit for that body as well,
ensuring nested async with cleanup scopes are detected by
statements_end_with_with_cleanup_scope_exit and preventing
preserve_outer_cleanup_target_nop from dropping needed NOPs.
- Around line 19608-19616: The test function
test_loop_not_in_conditional_body_threads_true_path_to_jump_back currently uses
the expression "not k in 'bBhHiIlLfd'" which parses as unary not applied to the
in comparison; update the test string passed to compile_exec inside that
function to use the dedicated NotIn operator by replacing "not k in
'bBhHiIlLfd'" with "k not in 'bBhHiIlLfd'" so the test actually exercises the
NotIn code path (locate the test by the function name and the compile_exec call
with the multi-line string).

In `@crates/codegen/src/ir.rs`:
- Around line 4672-4681: The helper leading_bool_guard_has_scope_exit_successor
currently inspects block.next directly and can be misled by empty layout blocks;
change the successor check to skip empty placeholders by normalizing each
successor with next_nonempty_block(blocks, successor) before testing for scope
exits. In practice, in leading_bool_guard_has_scope_exit_successor (and while
using trailing_conditional_jump_index and block_has_simple_scope_exit), map both
block.instructions[cond_idx].target and block.next through
next_nonempty_block(blocks, ...) and then perform the NULL check and
block_has_simple_scope_exit check on the normalized successor.

---

Duplicate comments:
In `@crates/codegen/src/ir.rs`:
- Around line 4648-4663: The helper block_has_simple_scope_exit currently treats
many opcodes as simple exits but still rejects lowered fast-local opcodes;
update the match in block_has_simple_scope_exit (the loop over
block.instructions) to also consider LoadFastCheck, StoreFastLoadFast, and
StoreFastStoreFast as simple scope exits (i.e., include them in the same
Some(Instruction::...) arm that returns true) so that
leading_bool_guard_has_scope_exit_successor will recognize structurally simple
cleanup successors after lowering; ensure you only add those opcode variants to
the existing accepted list and keep the early return behavior unchanged.
- Around line 2655-2679: The code computes preserves_pure_self_loop_anchor
before rewriting the conditional at block.instructions[i+1], so POP_JUMP_IF_*
<self> isn’t treated as unconditional and the NOP gets dropped; fix by computing
or re-checking the self-loop anchor after the rewrite (i.e., move or recompute
the preserves_pure_self_loop_anchor logic to run after the branch that sets
block.instructions[i+1] to an unconditional Jump) and then set
block.instructions[i].preserve_block_start_no_location_nop = true when the
recalculated condition holds; reference set_to_nop,
preserves_pure_self_loop_anchor, block.instructions, and
preserve_block_start_no_location_nop.