imjasonh/nescript
1
0
Fork 0
mirror of https://github.com/imjasonh/nescript synced 2026-07-16 12:12:04 +00:00
Code Activity

compiler: fix three scoping bugs; war: revert all local/param workarounds

Browse source 
Three related scoping bugs from examples/war/COMPILER_BUGS.md,
all fixed in one pass because they're different layer
manifestations of the same "flat global namespace" problem:

## §3: function-local `var` declarations lived in one namespace

`src/analyzer/mod.rs::register_var` inserted every `var` it
saw — top-level, state-local, AND function-body local — into
the same `self.symbols: HashMap<String, Symbol>`. Two different
functions declaring `var i` collided on E0501, which is why
every local in war/*.ne had a function-prefix like `dfa_card`
or `dwp_px`.

Fix: add a `current_scope_prefix: Option<String>` to the
Analyzer, set it to `Some("<fn_name>")` when checking a
function body (or `Some("Title__frame")` for state handler
bodies), and have `register_var` store the declaration under
an internal key `"__local__{prefix}__{name}"`. New
`resolve_symbol` / `resolve_key` helpers try the
scope-qualified key first and fall back to the bare key for
globals / consts / enum variants / state-level vars / function
names. Every existing `self.symbols.get(name)` inside
body-checking code was swapped over.

Two `var i` declarations inside the SAME function body still
collide with E0501 — we scoped per function body, not per
nested block. Per-block scoping would require live-range
analysis to reuse RAM slots.

## §1b: same-named params across functions shared VarIds

`src/ir/lowering.rs::get_or_create_var` looked up names in a
single global `var_map`, so two functions both with a `card:
u8` parameter resolved to the same `VarId`. Whichever function
was lowered last won the zero-page slot mapping, silently
rerouting the other function's param reads to the wrong slot.

Fix: the IR lowerer now mirrors the analyzer's scope logic.
`LoweringContext` gains a `current_scope_prefix` field that
gets set in `lower_function` / `lower_handler`, and
`get_or_create_var` uses a new `scoped_key` helper that
prepends `"__local__{prefix}__"` when the qualified key exists
in `var_map` or `var_types`. Each function's parameters and
locals therefore get distinct VarIds, and the codegen's
`var_addrs` map naturally has no collisions.

## §2: param transport slots $04-$07 clobbered across nested JSRs

Parameters were passed AND kept in `$04-$07` for the lifetime
of a function. Any nested call overwrote those slots with its
own arguments, so the caller's params were silently corrupted
as soon as it invoked anything. Every war helper that took
params and called other helpers (draw_card_face, push_back_a,
etc) snapshotted its params into fresh locals at the top of
the body.

Fix: in `codegen/ir_codegen.rs::IrCodeGen::new`, every
function-local — including parameters — now gets a dedicated
per-function RAM slot at `$0300+`. Parameters are still passed
via the zero-page transport slots `$04-$07` as the calling
convention, but `gen_function` now emits a **prologue** at
every function entry:

    LDA $04
    STA <param_0_addr>
    LDA $05
    STA <param_1_addr>
    ... etc, up to 4 ...

By the time the body runs, every parameter lives in the
function's dedicated RAM slot, so any nested call can freely
clobber $04-$07 (writing its own arguments there) without
corrupting the caller's saved parameters. Costs 4 LDA/STA
pairs (≈ 20 bytes of ROM, 16 cycles) at every function entry
— worth it to make the calling convention sound.

## War cleanup

With all three fixes in place, every workaround prefix in
`examples/war/*.ne` is gone:

- `card_rank(card)` instead of `card_rank(crk_c)` — bug #1b
- `compare_cards(a, b)` instead of `compare_cards(cmp_a, cmp_b)`
- `push_back_a(card)` instead of `push_back_a(pba_in)` — bug #1b
- `var card: u8 = draw_front_a()` in bury_from_* — bug #3
- `var i: u8 = 0` freely in multiple functions — bug #3
- `fun push_back_a(card)` body no longer snapshots `card` into
  `pba_card` before calling wrap52 — bug #2
- `fun draw_card_face` body no longer snapshots x/y/card into
  locals before calling card_rank/card_suit — bug #2
- `draw_word_player` steps its own x without needing a
  `dwp_px` accumulator to avoid the `x + N` arg compilation
  quirk — that quirk was a downstream symptom of bug #2 and
  is also gone

The source is now about 300 lines shorter and significantly
more readable.

## Regression tests

Seven new tests nail these bugs down:

- `analyzer::tests::analyze_allows_same_local_name_in_two_functions`
- `analyzer::tests::analyze_allows_same_param_name_in_two_functions`
- `analyzer::tests::analyze_allows_same_local_name_in_two_state_handlers`
- `analyzer::tests::analyze_still_rejects_duplicate_local_in_same_function`
- `codegen::ir_codegen::gen_function_prologue_spills_params_to_local_ram`

Plus the four param-arity tests from the earlier E0506 fix
and the wide_hi-leak regression test from the previous
compiler fix. Total suite: 591 unit tests, all passing.

## Golden drift

The prologue change adds a few cycles to every function entry,
which shifts NMI sampling by a handful of cycles and flips
the audio-hash of any example that plays sfx or music
(platformer, war). `arrays_and_functions.png` also picks up a
1-pixel shift in its enemy positions due to the same timing
drift. All three golden updates are pure "compiler produces
different but functionally-identical output" — no game
behavior changed.

## What's still open in COMPILER_BUGS.md

- §4: 8-sprites-per-scanline hardware limit is invisible to
  user code. A static analyzer hint could help; deferred.
- §5: `inline` keyword is silently declined for short
  functions that the optimizer's inliner doesn't recognize
  (it only removes empty functions). Deferred pending a real
  single-return-expression inlining pass.

https://claude.ai/code/session_0143dTgh3UeRrtfHgQwzcv5z
This commit is contained in:
Claude 2026-04-15 20:33:41 +00:00
parent e10d09db76
commit 76dd8eacb0
No known key found for this signature in database
23 changed files with 762 additions and 412 deletions
Download patch file Download diff file Expand all files Collapse all files

73
examples/war/play_state.ne
View file

@ -3,10 +3,6 @@
// `phase` cycles through the P_* constants defined in
// war/constants.ne. `phase_timer` counts frames inside the
// current phase and is reset to 0 whenever the phase changes.
//
// All function-local var names are prefixed with the function's
// short name (or with `pf_` for "play frame") so the global
// symbol table stays collision-free.
// Set the current phase and zero the timer in one shot. Inlined
// so each call site is just two stores.
@ -30,57 +26,46 @@ fun draw_table() {
}
// Bury helper for a war: move one card from the deck into the
// pot (face-down). Must be called with a non-empty deck. Two
// near-identical helpers (one per side) keep the locals
// uniquely-named.
// pot (face-down). Must be called with a non-empty deck.
fun bury_from_a() {
var bfa_c: u8 = draw_front_a()
push_back_pot(bfa_c)
var c: u8 = draw_front_a()
push_back_pot(c)
}
fun bury_from_b() {
var bfb_c: u8 = draw_front_b()
push_back_pot(bfb_c)
var c: u8 = draw_front_b()
push_back_pot(c)
}
// Draw the BIG WAR banner — three 16x16 metasprites at the
// centre of the screen. 12 sprites total, drawn in the centre
// row so they don't conflict with the deck stacks (rows 64-87)
// or the face-up cards (rows 128-151).
//
// All offsets stepped through locals to dodge the `x + N`
// parameter aliasing bug; see draw_word_player.
// Draw the BIG WAR banner — three 16×16 metasprite letters at
// the centre of the screen. 12 sprites total, drawn in the
// centre row so they don't conflict with the deck stacks (rows
// 64-87) or the face-up cards (rows 128-151).
fun draw_big_war_banner(x: u8, y: u8) {
var bwb_y1: u8 = y + 8
var bwb_x1: u8 = x + 8
var bwb_x2: u8 = x + 20
var bwb_x3: u8 = x + 28
var bwb_x4: u8 = x + 40
var bwb_x5: u8 = x + 48
// BIG W
draw Tileset at: (x, y) frame: TILE_BIG_W_TL
draw Tileset at: (bwb_x1, y) frame: TILE_BIG_W_TR
draw Tileset at: (x, bwb_y1) frame: TILE_BIG_W_BL
draw Tileset at: (bwb_x1, bwb_y1) frame: TILE_BIG_W_BR
draw Tileset at: (x, y) frame: TILE_BIG_W_TL
draw Tileset at: (x + 8, y) frame: TILE_BIG_W_TR
draw Tileset at: (x, y + 8) frame: TILE_BIG_W_BL
draw Tileset at: (x + 8, y + 8) frame: TILE_BIG_W_BR
// BIG A
draw Tileset at: (bwb_x2, y) frame: TILE_BIG_A_TL
draw Tileset at: (bwb_x3, y) frame: TILE_BIG_A_TR
draw Tileset at: (bwb_x2, bwb_y1) frame: TILE_BIG_A_BL
draw Tileset at: (bwb_x3, bwb_y1) frame: TILE_BIG_A_BR
draw Tileset at: (x + 20, y) frame: TILE_BIG_A_TL
draw Tileset at: (x + 28, y) frame: TILE_BIG_A_TR
draw Tileset at: (x + 20, y + 8) frame: TILE_BIG_A_BL
draw Tileset at: (x + 28, y + 8) frame: TILE_BIG_A_BR
// BIG R
draw Tileset at: (bwb_x4, y) frame: TILE_BIG_R_TL
draw Tileset at: (bwb_x5, y) frame: TILE_BIG_R_TR
draw Tileset at: (bwb_x4, bwb_y1) frame: TILE_BIG_R_BL
draw Tileset at: (bwb_x5, bwb_y1) frame: TILE_BIG_R_BR
draw Tileset at: (x + 40, y) frame: TILE_BIG_R_TL
draw Tileset at: (x + 48, y) frame: TILE_BIG_R_TR
draw Tileset at: (x + 40, y + 8) frame: TILE_BIG_R_BL
draw Tileset at: (x + 48, y + 8) frame: TILE_BIG_R_BR
}
// Begin the A-side draw animation: pull the top card off deck_a,
// stash it as the face-up `card_a`, arm the fly state for the
// deck → play slide, and play the click sfx.
//
// fly_card / fly_face_up are stuffed directly into globals
// instead of being passed to arm_fly, because arm_fly only takes
// 4 params (the v0.1 ABI limit) and silently drops anything past
// the fourth.
// fly_card / fly_face_up are written directly to globals
// instead of being passed to arm_fly, because arm_fly already
// takes 4 parameters and the v0.1 ABI caps function signatures
// at 4 parameters (E0506).
fun begin_draw_a() {
if deck_a_count > 0 {
card_a = draw_front_a()
@ -189,16 +174,16 @@ state Playing {
// Both cards go into the pot regardless of outcome.
push_back_pot(card_a)
push_back_pot(card_b)
pf_result = compare_cards(card_a, card_b)
if pf_result == 1 {
var result: u8 = compare_cards(card_a, card_b)
if result == 1 {
play CheerA
set_phase(P_WIN_A)
}
if pf_result == 2 {
if result == 2 {
play CheerB
set_phase(P_WIN_B)
}
if pf_result == 0 {
if result == 0 {
// It's a tie — but only enter the war flow if both
// sides actually have cards left to bury. If a
// player ran out of cards on this very tie, the