redscript-mc 1.2.24 → 1.2.26

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)
     })
 

package/src/__tests__/optimizer.test.ts

@@ -106,6 +106,39 @@ describe('deadCodeElimination', () => {
   })
 })
 
+describe('copyPropagation – stale alias invalidation', () => {
+  it('does not propagate $tmp = $y after $y is overwritten (swap pattern)', () => {
+    // Simulates: let tmp = y; y = x % y; x = tmp
+    // The copy $tmp = $y must be invalidated when $y is reassigned.
+    // Before fix: x = tmp was propagated to x = y (new y, wrong value).
+    const fn = makeFn([
+      { op: 'assign',  dst: '$tmp', src: { kind: 'var', name: '$y' } },          // tmp = y
+      { op: 'binop',   dst: '$r',   lhs: { kind: 'var', name: '$x' }, bop: '%', rhs: { kind: 'var', name: '$y' } }, // r = x%y
+      { op: 'assign',  dst: '$y',   src: { kind: 'var', name: '$r' } },           // y = r  ← stale: tmp still points to OLD y
+      { op: 'assign',  dst: '$x',   src: { kind: 'var', name: '$tmp' } },         // x = tmp (should NOT be x = y)
+    ])
+    const opt = copyPropagation(fn)
+    const instrs = opt.blocks[0].instrs
+    const xAssign = instrs.find((i: any) => i.dst === '$x') as any
+    // x = tmp must NOT be optimised to x = $y (stale) or x = $r (new y).
+    // It should stay as x = $tmp (the original copy).
+    expect(xAssign.src).toEqual({ kind: 'var', name: '$tmp' })
+  })
+
+  it('still propagates simple non-conflicting copies', () => {
+    // a = 5; b = a; c = b → after propagation b and c should both be const 5
+    const fn = makeFn([
+      { op: 'assign', dst: '$a', src: { kind: 'const', value: 5 } },
+      { op: 'assign', dst: '$b', src: { kind: 'var', name: '$a' } },
+      { op: 'assign', dst: '$c', src: { kind: 'var', name: '$b' } },
+    ])
+    const opt = copyPropagation(fn)
+    const instrs = opt.blocks[0].instrs
+    const cAssign = instrs.find((i: any) => i.dst === '$c') as any
+    expect(cAssign.src).toEqual({ kind: 'const', value: 5 })
+  })
+})
+
 describe('optimize pipeline', () => {
   it('combines all passes', () => {
     // t0 = 2 + 3  (→ constant fold → t0 = 5)

package/src/__tests__/stdlib-advanced.test.ts

@@ -0,0 +1,259 @@
+/**
+ * stdlib/advanced.mcrs — runtime behavioural tests
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import { compile } from '../compile'
+import { MCRuntime } from '../runtime'
+
+const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8')
+const ADV_SRC  = fs.readFileSync(path.join(__dirname, '../../src/stdlib/advanced.mcrs'), 'utf-8')
+
+function run(driver: string): MCRuntime {
+  const result = compile(driver, {
+    namespace: 'advtest',
+    librarySources: [MATH_SRC, ADV_SRC],
+  })
+  if (!result.success) throw new Error(result.error?.message ?? 'compile failed')
+  const rt = new MCRuntime('advtest')
+  for (const file of result.files ?? []) {
+    if (!file.path.endsWith('.mcfunction')) continue
+    const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/)
+    if (!match) continue
+    rt.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'))
+  }
+  rt.load()
+  return rt
+}
+
+function scoreOf(rt: MCRuntime, key: string): number {
+  return rt.getScore('out', `advtest.${key}`)
+}
+
+// ─── fib ─────────────────────────────────────────────────────────────────────
+
+describe('fib', () => {
+  it.each([
+    [0,  0],
+    [1,  1],
+    [2,  1],
+    [5,  5],
+    [10, 55],
+    [20, 6765],
+  ])('fib(%d) == %d', (n, expected) => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", fib(${n})); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(expected)
+  })
+})
+
+// ─── is_prime ─────────────────────────────────────────────────────────────────
+
+describe('is_prime', () => {
+  it.each([
+    [0, 0], [1, 0], [2, 1], [3, 1], [4, 0],
+    [7, 1], [9, 0], [11, 1], [97, 1], [100, 0],
+  ])('is_prime(%d) == %d', (n, expected) => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", is_prime(${n})); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(expected)
+  })
+})
+
+// ─── collatz_steps ───────────────────────────────────────────────────────────
+
+describe('collatz_steps', () => {
+  it.each([
+    [1,  0],
+    [2,  1],
+    [4,  2],
+    [6,  8],
+    [27, 111],
+  ])('collatz_steps(%d) == %d', (n, expected) => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", collatz_steps(${n})); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(expected)
+  })
+})
+
+// ─── digit helpers ───────────────────────────────────────────────────────────
+
+describe('digit_sum', () => {
+  it.each([
+    [0, 0], [1, 1], [9, 9], [123, 6], [999, 27], [-42, 6],
+  ])('digit_sum(%d) == %d', (n, expected) => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", digit_sum(${n})); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(expected)
+  })
+})
+
+describe('count_digits', () => {
+  it.each([
+    [0, 1], [9, 1], [10, 2], [100, 3], [9999, 4],
+  ])('count_digits(%d) == %d', (n, expected) => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", count_digits(${n})); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(expected)
+  })
+})
+
+describe('reverse_int', () => {
+  it.each([
+    [12345, 54321],
+    [100,   1],
+    [7,     7],
+  ])('reverse_int(%d) == %d', (n, expected) => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", reverse_int(${n})); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(expected)
+  })
+})
+
+// ─── mod_pow ─────────────────────────────────────────────────────────────────
+
+describe('mod_pow', () => {
+  it.each([
+    [2, 10, 1000, 24],    // 2^10 = 1024, 1024 mod 1000 = 24
+    [3,  4,  100, 81],    // 3^4 = 81
+    [2,  0,   10,  1],    // any^0 = 1
+    [5,  1,  100, 5],
+    [7,  3,   13, 343 % 13],  // 343 mod 13 = 5
+  ])('mod_pow(%d,%d,%d) == %d', (b, e, m, expected) => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", mod_pow(${b},${e},${m})); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(expected)
+  })
+})
+
+// ─── hash_int ────────────────────────────────────────────────────────────────
+
+describe('hash_int', () => {
+  it('is deterministic', () => {
+    const rt1 = run(`fn test() { scoreboard_set("out", "r", hash_int(42)); }`)
+    rt1.execFunction('test')
+    const rt2 = run(`fn test() { scoreboard_set("out", "r", hash_int(42)); }`)
+    rt2.execFunction('test')
+    expect(scoreOf(rt1, 'r')).toBe(scoreOf(rt2, 'r'))
+  })
+
+  it('different inputs → different outputs', () => {
+    const rt = run(`fn test() {
+      scoreboard_set("out", "a", hash_int(0));
+      scoreboard_set("out", "b", hash_int(1));
+      scoreboard_set("out", "c", hash_int(1000));
+    }`)
+    rt.execFunction('test')
+    const a = scoreOf(rt, 'a')
+    const b = scoreOf(rt, 'b')
+    const c = scoreOf(rt, 'c')
+    expect(a).not.toBe(b)
+    expect(b).not.toBe(c)
+  })
+
+  it('output is non-negative', () => {
+    for (const n of [-1000, -1, 0, 1, 999, 46340]) {
+      const rt = run(`fn test() { scoreboard_set("out", "r", hash_int(${n})); }`)
+      rt.execFunction('test')
+      expect(scoreOf(rt, 'r')).toBeGreaterThanOrEqual(0)
+    }
+  })
+})
+
+// ─── noise1d ─────────────────────────────────────────────────────────────────
+
+describe('noise1d', () => {
+  it('output in [0, 999]', () => {
+    for (const x of [0, 100, 500, 999, 1000, 2000]) {
+      const rt = run(`fn test() { scoreboard_set("out", "r", noise1d(${x})); }`)
+      rt.execFunction('test')
+      const v = scoreOf(rt, 'r')
+      expect(v).toBeGreaterThanOrEqual(0)
+      expect(v).toBeLessThan(1000)
+    }
+  })
+
+  it('is deterministic', () => {
+    const rt1 = run(`fn test() { scoreboard_set("out", "r", noise1d(1234)); }`)
+    rt1.execFunction('test')
+    const rt2 = run(`fn test() { scoreboard_set("out", "r", noise1d(1234)); }`)
+    rt2.execFunction('test')
+    expect(scoreOf(rt1, 'r')).toBe(scoreOf(rt2, 'r'))
+  })
+})
+
+// ─── bezier ──────────────────────────────────────────────────────────────────
+
+describe('bezier_quad', () => {
+  it.each([
+    [0, 500, 1000, 0,    0],     // t=0: start
+    [0, 500, 1000, 1000, 1000],  // t=1000: end
+    [0, 1000, 0,   500,  500],   // arch midpoint
+  ])('bezier_quad(%d,%d,%d,t=%d) == %d', (p0, p1, p2, t, expected) => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", bezier_quad(${p0},${p1},${p2},${t})); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(expected)
+  })
+})
+
+describe('bezier_cubic', () => {
+  it('t=0: start', () => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", bezier_cubic(0,333,667,1000,0)); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(0)
+  })
+  it('t=1000: end', () => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", bezier_cubic(0,333,667,1000,1000)); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(1000)
+  })
+})
+
+// ─── mandelbrot_iter ─────────────────────────────────────────────────────────
+
+describe('mandelbrot_iter', () => {
+  // c = 0 + 0i → always in set (z always 0)
+  it('origin (0,0) stays bounded for max_iter=20', () => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(0,0,20)); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(20)
+  })
+
+  // c = 2 + 0i → escapes immediately (|z1| = 2, |z2| = 6 > 2)
+  it('c=(2000,0) escapes quickly', () => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(2000,0,50)); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBeLessThan(5)
+  })
+
+  // c = -1 + 0i → stays bounded (period-2 cycle: 0 → -1 → 0 → ...)
+  it('c=(-1000,0) is in the set', () => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(-1000,0,50)); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(50)
+  })
+
+  // c = 0.5 + 0.5i → escapes
+  it('c=(500,500) escapes before max_iter=100', () => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(500,500,100)); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBeLessThan(100)
+  })
+})
+
+// ─── julia_iter ──────────────────────────────────────────────────────────────
+
+describe('julia_iter', () => {
+  it('z0=(0,0) with c=(0,0) stays bounded', () => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", julia_iter(0,0,0,0,20)); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(20)
+  })
+
+  it('z0=(3000,0) escapes immediately', () => {
+    const rt = run(`fn test() { scoreboard_set("out", "r", julia_iter(3000,0,0,0,20)); }`)
+    rt.execFunction('test')
+    expect(scoreOf(rt, 'r')).toBe(0)
+  })
+})