redscript-mc 1.2.25 → 1.2.27

package/examples/showcase.mcrs

@@ -0,0 +1,505 @@
+// ╔══════════════════════════════════════════════════════════════════════╗
+// ║  RedScript v1.2.26 — Capability Showcase                            ║
+// ║                                                                      ║
+// ║  Demonstrates every major feature in one datapack:                   ║
+// ║    • Math stdlib:    sin/cos table, sqrt_fixed, atan2, smoothstep    ║
+// ║    • Vec stdlib:     2D length, normalize, rotate                    ║
+// ║    • BigInt:         arbitrary-precision Fibonacci up to F(100)      ║
+// ║    • Advanced:       primes, Collatz, Bézier, noise, Mandelbrot      ║
+// ║    • Language:       structs, impl blocks, enums, match, lambdas,    ║
+// ║                      @tick/@load, foreach, f-strings, break/continue ║
+// ║    • Game effects:   particles, actionbar, fireworks, titles         ║
+// ║                                                                      ║
+// ║  Usage:                                                              ║
+// ║    /function showcase:start        begin the showcase                ║
+// ║    /function showcase:stop         stop everything                   ║
+// ║    /function showcase:dump_math    print math table to chat          ║
+// ║    /function showcase:dump_bigint  print Fibonacci to chat           ║
+// ╚══════════════════════════════════════════════════════════════════════╝
+
+import "../src/stdlib/math.mcrs"
+import "../src/stdlib/vec.mcrs"
+import "../src/stdlib/bigint.mcrs"
+import "../src/stdlib/advanced.mcrs"
+
+// ── Enums ─────────────────────────────────────────────────────────────────
+
+enum Phase {
+    Idle,       // 0 — waiting
+    Math,       // 1 — trig / fixed-point showcase
+    BigInt,     // 2 — arbitrary-precision arithmetic
+    Advanced,   // 3 — primes, noise, fractals
+    Visual,     // 4 — live particle ring + sin/cos actionbar
+}
+
+// ── State struct ───────────────────────────────────────────────────────────
+
+struct ShowcaseState {
+    phase:    int,   // current Phase
+    tick:     int,   // frame counter since start
+    angle:    int,   // 0–359 degrees; advances 2°/tick during Visual phase
+    running:  bool
+}
+
+let state: ShowcaseState = {
+    phase:   0,
+    tick:    0,
+    angle:   0,
+    running: false
+};
+
+// ── Timer (OOP demo) ───────────────────────────────────────────────────────
+
+struct ptimer {
+    interval: int,   // ticks between phase advances
+    elapsed:  int
+}
+
+impl ptimer {
+    fn new(interval: int) -> ptimer {
+        return { interval: interval, elapsed: 0 };
+    }
+
+    fn tick(self) -> bool {
+        self.elapsed = self.elapsed + 1;
+        if (self.elapsed >= self.interval) {
+            self.elapsed = 0;
+            return true;
+        }
+        return false;
+    }
+
+    fn reset(self) {
+        self.elapsed = 0;
+    }
+}
+
+let phase_timer: ptimer = { interval: 200, elapsed: 0 };   // advance every 10 seconds
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+fn _divider() {
+    say("§8§m══════════════════════════════");
+}
+
+fn _section(title: string) {
+    _divider();
+    say(f"§6§l  {title}");
+    _divider();
+}
+
+// Format a fixed-point ×1000 value as "X.XXX"
+fn _fp(n: int) -> int {
+    // Just return raw for now; f-string handles display
+    return n;
+}
+
+// ── @load ─────────────────────────────────────────────────────────────────
+
+@load
+fn showcase_load() {
+    say("§a[Showcase] §rRedScript v1.2.26 loaded.");
+    say("§7  /function showcase:start  §f— begin the showcase");
+    say("§7  /function showcase:dump_math  §f— print math tables");
+    say("§7  /function showcase:dump_bigint  §f— print big Fibonacci numbers");
+}
+
+// ── @tick ──────────────────────────────────────────────────────────────────
+
+@tick
+fn showcase_tick() {
+    if (!state.running) { return; }
+
+    state.tick = state.tick + 1;
+
+    // Advance phase on timer
+    if (phase_timer.tick()) {
+        _next_phase();
+    }
+
+    // Per-phase work
+    match (state.phase) {
+        Phase.Math     => { _tick_math(); }
+        Phase.BigInt   => { _tick_bigint_live(); }
+        Phase.Advanced => { _tick_advanced_live(); }
+        Phase.Visual   => { _tick_visual(); }
+    }
+}
+
+fn _next_phase() {
+    state.phase = state.phase + 1;
+    if (state.phase > 4) { state.phase = 1; }
+
+    match (state.phase) {
+        Phase.Math     => { _dump_math_phase(); }
+        Phase.BigInt   => { _dump_bigint_phase(); }
+        Phase.Advanced => { _dump_advanced_phase(); }
+        Phase.Visual   => {
+            _section("Live Visual FX");
+            say("§bOrbital ring + live sin/cos on actionbar.");
+            say("§7(runs for 10 seconds, then loops back to Math)");
+        }
+    }
+}
+
+// ── Phase 1: Math Stdlib ──────────────────────────────────────────────────
+
+fn _dump_math_phase() {
+    _section("Math Stdlib — Fixed-Point Trigonometry");
+
+    // Sin/cos table samples
+    say("§eTrig (×1000 fixed-point):");
+    let deg: int = 0;
+    while (deg <= 90) {
+        let s: int = sin_fixed(deg);
+        let c: int = cos_fixed(deg);
+        say(f"  sin({deg}°)={s}  cos({deg}°)={c}");
+        deg = deg + 15;
+    }
+
+    // sqrt, pow, gcd, lcm
+    say("§eRoots & Powers:");
+    say(f"  sqrt_fixed(2) = {sqrt_fixed(2)}  (expect 1414)");
+    say(f"  sqrt_fixed(3) = {sqrt_fixed(3)}  (expect 1732)");
+    say(f"  isqrt(360000000000) = {isqrt(360000000000)}  (expect 600000)");
+    say(f"  pow_int(2, 20) = {pow_int(2, 20)}  (expect 1048576)");
+
+    say("§eNumber Theory:");
+    say(f"  gcd(48, 36) = {gcd(48, 36)}  (expect 12)");
+    say(f"  lcm(4, 6) = {lcm(4, 6)}  (expect 12)");
+    say(f"  log2_int(1024) = {log2_int(1024)}  (expect 10)");
+
+    say("§eInterpolation:");
+    say(f"  lerp(0, 1000, 250) = {lerp(0, 1000, 250)}  (expect 250)");
+    say(f"  smoothstep(0,1000,0)   = {smoothstep(0, 1000, 0)}");
+    say(f"  smoothstep(0,1000,500) = {smoothstep(0, 1000, 500)}  (expect ~500)");
+    say(f"  smoothstep(0,1000,1000)= {smoothstep(0, 1000, 1000)}");
+    say(f"  smootherstep(0,1000,500)={smootherstep(0, 1000, 500)}");
+
+    say("§eFixed-Point Multiply/Divide:");
+    say(f"  mulfix(1414, 1414) = {mulfix(1414, 1414)}  (≈ 2×1000=2000)");
+    say(f"  divfix(1000, 3) = {divfix(1000, 3)}  (≈ 333)");
+}
+
+fn _tick_math() {
+    // Animate: show atan2 of a rotating unit vector on actionbar
+    state.angle = (state.angle + 3) % 360;
+    let s: int = sin_fixed(state.angle);
+    let c: int = cos_fixed(state.angle);
+    let theta: int = atan2_fixed(s, c);         // returns degrees directly
+    foreach (p in @a[limit=1]) {
+        actionbar(p, f"§bsin={s} §dcos={c} §eatan2={theta}°");
+    }
+}
+
+// ── Phase 2: BigInt ───────────────────────────────────────────────────────
+
+fn _dump_bigint_phase() {
+    _section("BigInt — 32-Digit Arbitrary Precision");
+
+    say("§eFibonacci sequence (BigInt, base-10000 limbs):");
+
+    // Small Fibonacci — fits in single limb
+    let i: int = 0;
+    while (i <= 20) {
+        bigint_fib(i);
+        let v: int = bigint_get_a(0);
+        say(f"  F({i}) = {v}");
+        i = i + 5;
+    }
+
+    // F(50) = 12,586,269,025 (3 limbs)
+    bigint_fib(50);
+    let f50_2: int = bigint_get_a(2);
+    let f50_1: int = bigint_get_a(1);
+    let f50_0: int = bigint_get_a(0);
+    say(f"  F(50) = {f50_2}_{f50_1}_{f50_0}  [= 12,586,269,025]");
+
+    // F(100) = 354,224,848,179,261,915,075 (6 limbs)
+    bigint_fib(100);
+    let f100_5: int = bigint_get_a(5);
+    let f100_4: int = bigint_get_a(4);
+    let f100_3: int = bigint_get_a(3);
+    let f100_2: int = bigint_get_a(2);
+    let f100_1: int = bigint_get_a(1);
+    let f100_0: int = bigint_get_a(0);
+    say(f"  F(100)= {f100_5}_{f100_4}_{f100_3}_{f100_2}_{f100_1}_{f100_0}");
+    say(f"  [= 354,224,848,179,261,915,075]");
+
+    // BigInt multiplication: 999999999 × 999999999
+    say("§eBigInt Multiply:");
+    bigint_init();
+    bigint_from_int_a(999999999);
+    bigint_from_int_b(999999999);
+    bigint_mul();
+    let m2: int = bigint_get_c(2);
+    let m1: int = bigint_get_c(1);
+    let m0: int = bigint_get_c(0);
+    say(f"  999999999² = {m2}_{m1}_{m0}");
+    say(f"  [= 999999998_000000001]");
+
+    // BigInt subtract
+    say("§eBigInt Subtract:");
+    bigint_init();
+    bigint_from_int_a(1000000000);
+    bigint_from_int_b(1);
+    bigint_sub();
+    let s0: int = bigint_get_c(0);
+    let s1: int = bigint_get_c(1);
+    say(f"  1,000,000,000 - 1 = {s1}_{s0}  [= 999999999]");
+}
+
+fn _tick_bigint_live() {
+    // Show incremental Fibonacci on actionbar
+    if (state.tick % 10 == 0) {
+        let n: int = (state.tick / 10) % 30;
+        bigint_fib(n);
+        let v0: int = bigint_get_a(0);
+        let v1: int = bigint_get_a(1);
+        foreach (p in @a[limit=1]) {
+            actionbar(p, f"§dF({n}) limb[1]={v1} limb[0]={v0}");
+        }
+    }
+}
+
+// ── Phase 3: Advanced Stdlib ──────────────────────────────────────────────
+
+fn _dump_advanced_phase() {
+    _section("Advanced Stdlib — Number Theory & More");
+
+    // Primes
+    say("§ePrime numbers up to 50:");
+    let j: int = 2;
+    while (j <= 50) {
+        if (is_prime(j) == 1) {
+            say(f"  {j}");
+        }
+        j = j + 1;
+    }
+
+    // Collatz conjecture
+    say("§eCollatz sequences:");
+    say(f"  collatz_steps(27)  = {collatz_steps(27)}  (expect 111)");
+    say(f"  collatz_steps(97)  = {collatz_steps(97)}");
+    say(f"  collatz_steps(871) = {collatz_steps(871)}  (longest for n≤1000)");
+
+    // Number utilities
+    say("§eNumber Utilities:");
+    say(f"  digit_sum(9999)   = {digit_sum(9999)}   (expect 36)");
+    say(f"  reverse_int(12345)= {reverse_int(12345)} (expect 54321)");
+    say(f"  digital_root(493) = {digital_root(493)}  (expect 7)");
+
+    // Hash & noise
+    say("§eHash (splitmix32) & 1D Noise:");
+    say(f"  hash_int(0)   = {hash_int(0)}");
+    say(f"  hash_int(1)   = {hash_int(1)}");
+    say(f"  noise1d(0,42) = {noise1d(0, 42)}");
+    say(f"  noise1d(1,42) = {noise1d(1, 42)}");
+    say(f"  noise1d(2,42) = {noise1d(2, 42)}");
+
+    // Modular exponentiation
+    say("§eModular Exponentiation:");
+    say(f"  mod_pow(2, 10, 1000) = {mod_pow(2, 10, 1000)}  (expect 24)");
+    say(f"  mod_pow(7, 5, 13) = {mod_pow(7, 5, 13)}  (expect 11)  // NOTE: m<46340 to avoid INT32 overflow");
+
+    // Bézier curve
+    say("§eQuadratic Bézier (P0=0, P1=1000, P2=0) — shape like ∩:");
+    let t: int = 0;
+    while (t <= 1000) {
+        let bz: int = bezier_quad(0, 1000, 0, t);
+        say(f"  t={t}  → {bz}");
+        t = t + 200;
+    }
+
+    // Mandelbrot iteration counts at selected points
+    say("§eMandelbrot Iteration Counts:");
+    say(f"  (0, 0)       → {mandelbrot_iter(0, 0, 50)} iters  [inside set]");
+    say(f"  (2000, 0)    → {mandelbrot_iter(2000, 0, 50)} iters  [outside]");
+    say(f"  (-1250, 0)   → {mandelbrot_iter(-1250, 0, 50)} iters  [boundary]");
+    say(f"  (-750, 1000) → {mandelbrot_iter(-750, 1000, 50)} iters  [boundary]");
+
+    // Vec math
+    say("§eVector Math (×1000 fixed-point):");
+    say(f"  length2d_fixed(3, 4) = {length2d_fixed(3, 4)}  (expect 5000)");
+    say(f"  dot2d(1000,0, 0,1000) = {dot2d(1000, 0, 0, 1000)}  (perpendicular = 0)");
+    say(f"  dot2d(1000,0, 1000,0) = {dot2d(1000, 0, 1000, 0)}  (parallel = 1e6)");
+    say(f"  atan2_fixed(1000, 1000) = {atan2_fixed(1000, 1000)}°  (expect 45)");
+    say(f"  normalize2d_x(3, 4) = {normalize2d_x(3, 4)}  (expect 600)");
+    say(f"  normalize2d_y(3, 4) = {normalize2d_y(3, 4)}  (expect 800)");
+}
+
+fn _tick_advanced_live() {
+    // Scan Mandelbrot x-axis in real time on actionbar
+    if (state.tick % 5 == 0) {
+        let cx: int = -2000 + (state.tick % 200) * 20;  // -2000 to 2000
+        let iters: int = mandelbrot_iter(cx, 0, 30);
+        foreach (p in @a[limit=1]) {
+            actionbar(p, f"§aMandelbrot scan: cx={cx}  iters={iters}");
+        }
+    }
+}
+
+// ── Phase 4: Visual Effects ────────────────────────────────────────────────
+
+fn _tick_visual() {
+    // Advance rotation angle
+    state.angle = (state.angle + 2) % 360;
+
+    // Live sin/cos on actionbar
+    let s: int = sin_fixed(state.angle);
+    let c: int = cos_fixed(state.angle);
+    let len: int = length2d_fixed(s, c);
+    foreach (p in @a[limit=1]) {
+        actionbar(p, f"§6angle={state.angle}°  §bsin={s}  §dcos={c}  §alen={len}");
+    }
+
+    // Particle ring: 8 cardinal + diagonal points pulsing in Y
+    // Y-offset is driven by sin (rises and falls with angle)
+    // Note: ~Y syntax uses a macro param; we use fixed ~1 here and
+    // place two rings (ground ~0 and elevated ~2) at alternating ticks
+    if (state.tick % 2 == 0) {
+        foreach (p in @a[limit=1]) at @s {
+            // Cardinal — end_rod (blue-white)
+            particle("minecraft:end_rod", ~0,  ~1, ~5,  0, 0, 0, 0, 1);
+            particle("minecraft:end_rod", ~5,  ~1, ~0,  0, 0, 0, 0, 1);
+            particle("minecraft:end_rod", ~0,  ~1, ~-5, 0, 0, 0, 0, 1);
+            particle("minecraft:end_rod", ~-5, ~1, ~0,  0, 0, 0, 0, 1);
+            // Diagonal — flame (orange)
+            particle("minecraft:flame", ~3,  ~1, ~3,  0, 0, 0, 0, 1);
+            particle("minecraft:flame", ~-3, ~1, ~3,  0, 0, 0, 0, 1);
+            particle("minecraft:flame", ~3,  ~1, ~-3, 0, 0, 0, 0, 1);
+            particle("minecraft:flame", ~-3, ~1, ~-3, 0, 0, 0, 0, 1);
+        }
+    } else {
+        foreach (p in @a[limit=1]) at @s {
+            // Upper ring offset by 2 (creates helix effect alternating ticks)
+            particle("minecraft:end_rod", ~0,  ~3, ~5,  0, 0, 0, 0, 1);
+            particle("minecraft:end_rod", ~5,  ~3, ~0,  0, 0, 0, 0, 1);
+            particle("minecraft:end_rod", ~0,  ~3, ~-5, 0, 0, 0, 0, 1);
+            particle("minecraft:end_rod", ~-5, ~3, ~0,  0, 0, 0, 0, 1);
+            particle("minecraft:flame", ~3,  ~3, ~3,  0, 0, 0, 0, 1);
+            particle("minecraft:flame", ~-3, ~3, ~3,  0, 0, 0, 0, 1);
+            particle("minecraft:flame", ~3,  ~3, ~-3, 0, 0, 0, 0, 1);
+            particle("minecraft:flame", ~-3, ~3, ~-3, 0, 0, 0, 0, 1);
+        }
+    }
+
+    // Firework burst at tick multiples of 100
+    if (state.tick % 100 == 0) {
+        foreach (p in @a[limit=1]) at @s {
+            summon("minecraft:firework_rocket", ~0, ~2, ~0);
+        }
+    }
+}
+
+// ── Public commands ────────────────────────────────────────────────────────
+
+fn start() {
+    state.running = true;
+    state.phase   = 0;
+    state.tick    = 0;
+    state.angle   = 0;
+    phase_timer.reset();
+
+    _section("RedScript v1.2.26 Showcase");
+    say("§aStarting capability demo — phases cycle every 10 seconds.");
+    say("§7Math → BigInt → Advanced → Visual FX → (repeat)");
+    say("§7Use §f/function showcase:dump_math §7or §f/function showcase:dump_bigint");
+    say("§7for the full printed output at any time.");
+
+    // Kick off phase 1 immediately
+    _next_phase();
+}
+
+fn stop() {
+    state.running = false;
+    foreach (p in @a[limit=1]) {
+        actionbar(p, "§c[Showcase stopped]");
+    }
+    say("§c[Showcase] §rStopped.");
+}
+
+// Stand-alone dump commands for reference
+
+fn dump_math() {
+    _dump_math_phase();
+}
+
+fn dump_bigint() {
+    _dump_bigint_phase();
+}
+
+fn dump_advanced() {
+    _dump_advanced_phase();
+}
+
+// ── BigInt step-by-step debug ─────────────────────────────────────────────
+// /function showcase:debug_bigint
+fn debug_bigint() {
+    say("§e=== BigInt Debug ===");
+
+    // Step 0: check scoreboard objective 'rs' exists (set by __load)
+    // If this reads 0, __load hasn't run — do /reload first!
+    scoreboard_set("__dbgcheck", #rs, 9999);
+    let rs_check: int = scoreboard_get("__dbgcheck", #rs);
+    say(f"§7[0] rs-objective check={rs_check}  (expect 9999; if 0 → run /reload first!)");
+
+    // Step 1: init
+    bigint_init();
+    say("§7[1] bigint_init() done");
+
+    // Step 2: from_int_a (STATIC index writes, no macro)
+    bigint_from_int_a(12345);
+    // 2a: static read (data get storage rs:bigint a[0] — NO macro)
+    let direct0: int = storage_get_int("rs:bigint", "a", 0);
+    let direct1: int = storage_get_int("rs:bigint", "a", 1);
+    say(f"§7[2a] static-read a[0]={direct0}  a[1]={direct1}  (expect 2345,1)");
+    // 2b: macro read (bigint_get_a uses macro sub-function)
+    let a0: int = bigint_get_a(0);
+    let a1: int = bigint_get_a(1);
+    say(f"§7[2b] macro-read  a[0]={a0}  a[1]={a1}  (expect 2345,1)");
+
+    // Step 3: fib(1) = 1  (no carry, simplest case)
+    bigint_fib(1);
+    let f1: int = bigint_get_a(0);
+    say(f"§7[3] fib(1) → get_a(0)={f1}  (expect 1)");
+
+    // Step 4: fib(5) = 5
+    bigint_fib(5);
+    let f5: int = bigint_get_a(0);
+    say(f"§7[4] fib(5) → get_a(0)={f5}  (expect 5)");
+
+    // Step 5: fib(10) = 55
+    bigint_fib(10);
+    let f10: int = bigint_get_a(0);
+    say(f"§7[5] fib(10) → get_a(0)={f10}  (expect 55)");
+
+    // Step 6: fib(20) = 6765
+    bigint_fib(20);
+    let f20: int = bigint_get_a(0);
+    say(f"§7[6] fib(20) → get_a(0)={f20}  (expect 6765)");
+
+    // Step 7: manual add — bigint_add() writes via __ssi macro
+    bigint_init();
+    bigint_from_int_a(1);
+    bigint_from_int_b(1);
+    bigint_add();
+    let c0: int = bigint_get_c(0);
+    say(f"§7[7] 1+1=? get_c(0)={c0}  (expect 2)");
+
+    say("§a=== Done ===");
+}
+
+// ── Lambda demo (standalone — shows higher-order functions work) ───────────
+
+fn _apply(f: (int) -> int, x: int) -> int {
+    return f(x);
+}
+
+fn lambda_demo() {
+    let double: (int) -> int = (x: int) => x * 2;
+    let square: (int) -> int = (x: int) => x * x;
+
+    say(f"  double(7) = {_apply(double, 7)}");
+    say(f"  square(9) = {_apply(square, 9)}");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.25",
+  "version": "1.2.27",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/cli.test.ts

@@ -173,7 +173,7 @@ describe('CLI API', () => {
       const mainFn = result.files.find(file => file.path.endsWith('/main.mcfunction'))
       expect(doneFn?.content).toContain('scoreboard players get timer_ticks rs')
       expect(doneFn?.content).toContain('return run scoreboard players get')
-      expect(mainFn?.content).toContain('execute if score $finished rs matches 1..')
+      expect(mainFn?.content).toContain('execute if score $main_finished rs matches 1..')
     })
 
     it('Timer.tick increments', () => {

package/src/__tests__/codegen.test.ts

@@ -19,26 +19,32 @@ describe('generateDatapack', () => {
   })
 
   it('generates function file for simple add(a, b)', () => {
+    // IR now uses { kind: 'param', index: i } for param-copy instructions,
+    // matching what the lowering emits.  Pass mangle:false so we can check
+    // readable names without worrying about sequential mangled names.
     const mod: IRModule = {
       namespace: 'mypack',
       globals: [],
       functions: [{
         name: 'add',
-        params: ['a', 'b'],
-        locals: ['a', 'b', 'result'],
+        params: ['$a', '$b'],
+        locals: ['$a', '$b', '$result'],
         blocks: [{
           label: 'entry',
           instrs: [
-            { op: 'binop', dst: 'result', lhs: { kind: 'var', name: 'a' }, bop: '+', rhs: { kind: 'var', name: 'b' } },
+            // param-copy instructions (what the lowering now emits)
+            { op: 'assign', dst: '$a', src: { kind: 'param', index: 0 } },
+            { op: 'assign', dst: '$b', src: { kind: 'param', index: 1 } },
+            { op: 'binop', dst: '$result', lhs: { kind: 'var', name: '$a' }, bop: '+', rhs: { kind: 'var', name: '$b' } },
           ],
-          term: { op: 'return', value: { kind: 'var', name: 'result' } },
+          term: { op: 'return', value: { kind: 'var', name: '$result' } },
         }],
       }],
     }
-    const files = generateDatapack(mod)
+    const files = generateDatapackWithStats(mod, { mangle: false }).files
     const fn = files.find(f => f.path.includes('add.mcfunction'))
     expect(fn).toBeDefined()
-    // Should have param setup
+    // param setup emitted from the IR
     expect(fn!.content).toContain('scoreboard players operation $a rs = $p0 rs')
     expect(fn!.content).toContain('scoreboard players operation $b rs = $p1 rs')
     // Should have add operation

package/src/__tests__/e2e.test.ts

@@ -124,7 +124,7 @@ fn main() {
 `)
       const mainFn = getFunction(files, 'main')
       expect(mainFn).toBeDefined()
-      expect(mainFn).toContain('scoreboard players set $hp rs 105')
+      expect(mainFn).toContain('scoreboard players set $main_hp rs 105')
       expect(mainFn).toContain('Arena Battle')
     })
   })
@@ -1852,7 +1852,7 @@ describe('for-range loop', () => {
     const src = `fn test() { for i in 0..5 { say("hi"); } }`
     const files = compile(src, 'forloop')
     const fn = getFunction(files, 'test')
-    expect(fn).toContain('scoreboard players set $i rs 0')
+    expect(fn).toContain('scoreboard players set $test_i rs 0')
   })
 
   it('generates loop sub-function with increment and condition', () => {
@@ -1861,17 +1861,17 @@ describe('for-range loop', () => {
     const subFn = files.find(f => f.path.includes('__for_0'))
     expect(subFn).toBeDefined()
     expect(subFn?.content).toContain('say hi')
-    expect(subFn?.content).toContain('scoreboard players add $i rs 1')
-    expect(subFn?.content).toContain('execute if score $i rs matches ..4 run function forloop:test/__for_0')
+    expect(subFn?.content).toContain('scoreboard players add $test_i rs 1')
+    expect(subFn?.content).toContain('execute if score $test_i rs matches ..4 run function forloop:test/__for_0')
   })
 
   it('supports non-zero start', () => {
     const src = `fn test() { for x in 3..8 { say("loop"); } }`
     const files = compile(src, 'forloop2')
     const fn = getFunction(files, 'test')
-    expect(fn).toContain('scoreboard players set $x rs 3')
+    expect(fn).toContain('scoreboard players set $test_x rs 3')
     const subFn = files.find(f => f.path.includes('__for_0'))
-    expect(subFn?.content).toContain('execute if score $x rs matches ..7 run function forloop2:test/__for_0')
+    expect(subFn?.content).toContain('execute if score $test_x rs matches ..7 run function forloop2:test/__for_0')
   })
 })
 

package/src/__tests__/lowering.test.ts

@@ -50,7 +50,7 @@ describe('Lowering', () => {
       const fn = getFunction(ir, 'foo')!
       const instrs = getInstructions(fn)
       expect(instrs.some(i =>
-        i.op === 'assign' && i.dst === '$x' && (i.src as any).name === '$p0'
+        i.op === 'assign' && i.dst === '$foo_x' && (i.src as any).kind === 'param' && (i.src as any).index === 0
       )).toBe(true)
     })
 
@@ -139,7 +139,7 @@ fn foo() {
       const fn = getFunction(ir, 'foo')!
       const instrs = getInstructions(fn)
       expect(instrs.some(i =>
-        i.op === 'assign' && i.dst === '$x' && (i.src as any).kind === 'const' && (i.src as any).value === 100
+        i.op === 'assign' && i.dst === '$foo_x' && (i.src as any).kind === 'const' && (i.src as any).value === 100
       )).toBe(true)
       expect(ir.globals).not.toContain('$MAX_HP')
     })
@@ -149,7 +149,7 @@ fn foo() {
       const fn = getFunction(ir, 'foo')!
       const instrs = getInstructions(fn)
       expect(instrs.some(i =>
-        i.op === 'assign' && i.dst === '$x' && (i.src as any).value === 42
+        i.op === 'assign' && i.dst === '$foo_x' && (i.src as any).value === 42
       )).toBe(true)
     })
 
@@ -579,16 +579,16 @@ fn choose(dir: Direction) {
       const ir = compile('fn test() { let score: int = 7; say("You have ${score} points"); }')
       const fn = getFunction(ir, 'test')!
       const rawCmds = getRawCommands(fn)
-      expect(rawCmds).toContain('tellraw @a ["",{"text":"You have "},{"score":{"name":"$score","objective":"rs"}},{"text":" points"}]')
+      expect(rawCmds).toContain('tellraw @a ["",{"text":"You have "},{"score":{"name":"$test_score","objective":"rs"}},{"text":" points"}]')
     })
 
     it('lowers f-string output builtins to tellraw/title JSON components', () => {
       const ir = compile('fn test() { let score: int = 7; say(f"Score: {score}"); tellraw(@a, f"Score: {score}"); actionbar(@s, f"Score: {score}"); title(@s, f"Score: {score}"); }')
       const fn = getFunction(ir, 'test')!
       const rawCmds = getRawCommands(fn)
-      expect(rawCmds).toContain('tellraw @a ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]')
-      expect(rawCmds).toContain('title @s actionbar ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]')
-      expect(rawCmds).toContain('title @s title ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]')
+      expect(rawCmds).toContain('tellraw @a ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]')
+      expect(rawCmds).toContain('title @s actionbar ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]')
+      expect(rawCmds).toContain('title @s title ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]')
     })
 
     it('lowers summon()', () => {
@@ -1149,7 +1149,7 @@ fn count_down() {
       const fn = getFunction(ir, 'test')!
       const instrs = getInstructions(fn)
       expect(instrs.some(i =>
-        i.op === 'assign' && i.dst === '$y' && (i.src as any).kind === 'var' && (i.src as any).name === '$count'
+        i.op === 'assign' && i.dst === '$test_y' && (i.src as any).kind === 'var' && (i.src as any).name === '$count'
       )).toBe(true)
     })