Fix future annotation block alignment - #8506

#!/bin/bash
# Description: Trace callers of consume_function_annotation_symbol_table_if_used
# and check whether skipped FunctionDef nodes without annotations can reach it
# under future annotations.
set -euo pipefail

rg -n -C 5 'consume_function_annotation_symbol_table_if_used' crates/codegen/src/compile.rs

#!/bin/bash
set -euo pipefail
sed -n '9960,10420p' crates/codegen/src/compile.rs
printf '\n--- annotation-table helpers ---\n'
sed -n '1560,1670p' crates/codegen/src/compile.rs
printf '\n--- relevant tests and visitor references ---\n'
rg -n -C 8 'SkippedStatementScopeVisitor|future_unannotated_function|except-handler|except handler|annotation_symbol_table|hidden_annotation_blocks' crates/codegen/src/compile.rs

#!/bin/bash
set -euo pipefail
printf '%s\n' '--- skipped-scope call sites ---'
rg -n -C 12 'consume_skipped_nested_scopes_in_(statements|except_handlers|expr)' crates/codegen/src/compile.rs
printf '%s\n' '--- exception compilation paths ---'
rg -n -C 18 'consume_skipped_nested_scopes_in_except_handlers|SkippedHandlerScopeVisitor|compile.*except|ExceptHandler' crates/codegen/src/compile.rs
printf '%s\n' '--- symbol-table construction for hidden annotation blocks ---'
rg -n -C 12 'hidden_annotation_blocks|next_hidden_annotation_block|annotations_used.*Annotation|AnnotationBlock' crates/codegen/src crates/compiler crates -g '*.rs'

#!/bin/bash
set -euo pipefail
printf '%s\n' '--- function-definition compilation ---'
rg -n -C 20 'Stmt::FunctionDef|compile_function|compile_annotations_closure' crates/codegen/src/compile.rs | head -n 260
printf '%s\n' '--- symbol-table cursor helpers ---'
rg -n -C 16 'fn push_symbol_table|fn pop_symbol_table|fn current_symbol_table_cursors|fn set_symbol_table_cursors|fn compile_statements' crates/codegen/src/compile.rs
printf '%s\n' '--- try/except cursor movement ---'
sed -n '4327,4425p' crates/codegen/src/compile.rs

#!/bin/bash
set -euo pipefail
python3 - <<'PY'
from pathlib import Path

source = Path("crates/codegen/src/compile.rs").read_text()

required = [
    "self.consume_skipped_nested_scopes_in_except_handlers(handlers)?;",
    "self.compile_statements(orelse)?;",
    "self.set_symbol_table_cursors(handler_symbol_table_cursors);",
    "self.compiler.consume_function_annotation_symbol_table_if_used()",
    "self.visit_parameter_defaults(parameters);",
    "self.consume_function_annotation_scope_if_used();",
    "self.consume_scope();",
    "if !self.next_function_annotation_symbol_table_uses_annotations()",
    "return Ok(());",
]
for fragment in required:
    assert fragment in source, f"missing source fragment: {fragment}"

# Model the relevant cursor operations for:
# handler: def plain(x): pass
# orelse:  def annotated(x: int): pass
hidden_blocks = [("plain", False), ("annotated", True)]
hidden_cursor = 0
sub_cursor = 0

# SkippedStatementScopeVisitor visits the handler FunctionDef.
# The current implementation does not consume an unused annotation block.
uses_annotations = hidden_blocks[hidden_cursor][1]
if uses_annotations:
    hidden_cursor += 1
sub_cursor += 1  # consume the FunctionBlock

assert hidden_cursor == 0
assert sub_cursor == 1

# Codegen then compiles the orelse. Its function definition consumes the
# still-current hidden block, so it sees the handler's unused block.
orelse_seen = hidden_blocks[hidden_cursor]
assert orelse_seen == ("plain", False), orelse_seen
assert orelse_seen[1] is False

print("reachable path: try/except skips handler scopes before compiling orelse")
print("current skipped consumer leaves the unannotated handler AnnotationBlock")
print("next orelse function therefore receives the handler block")
print("the sibling gap reproduces the same hidden-block cursor misalignment")
PY

#!/bin/bash
set -euo pipefail
python3 - <<'PY'
from pathlib import Path
import re

source = Path("crates/codegen/src/compile.rs").read_text()

required_patterns = [
    r"consume_skipped_nested_scopes_in_except_handlers\(handlers\)\?",
    r"compile_statements\(orelse\)\?",
    r"set_symbol_table_cursors\(handler_symbol_table_cursors\)",
    r"compiler\s*\.\s*consume_function_annotation_symbol_table_if_used\(\)",
    r"visit_parameter_defaults\(parameters\)",
    r"consume_function_annotation_scope_if_used\(\)",
    r"consume_scope\(\)",
    r"if !self\.next_function_annotation_symbol_table_uses_annotations\(\)",
    r"return Ok\(\(\)\);",
]
for pattern in required_patterns:
    assert re.search(pattern, source), f"missing source pattern: {pattern}"

# Under future annotations, the parent scope stores one hidden AnnotationBlock
# per function in AST order, including unannotated functions.
hidden_blocks = [("handler_plain", False), ("orelse_annotated", True)]
hidden_cursor = 0
sub_cursor = 0

# SkippedStatementScopeVisitor visits the handler FunctionDef.
# The sibling consumer returns without advancing for an unused block.
uses_annotations = hidden_blocks[hidden_cursor][1]
if uses_annotations:
    hidden_cursor += 1
sub_cursor += 1  # consume the FunctionBlock

assert hidden_cursor == 0
assert sub_cursor == 1

# Orelse is compiled before the real handler body. Its next function therefore
# observes the handler's unused AnnotationBlock.
orelse_observed = hidden_blocks[hidden_cursor]
assert orelse_observed == ("handler_plain", False), orelse_observed

print("reachable: try/except skips handler scopes before compiling orelse")
print("skipped unannotated FunctionDef leaves its hidden AnnotationBlock")
print("next orelse FunctionDef observes the stale hidden block")
print("sibling consumer has the same cursor-alignment gap")
PY