redscript-mc 1.2.30 → 2.0.0

package/src/__tests__/optimizer.test.ts

@@ -1,162 +0,0 @@
-import { constantFolding, copyPropagation, deadCodeElimination, optimize } from '../optimizer/passes'
-import type { IRFunction } from '../ir/types'
-
-function makeFn(instrs: any[], term: any = { op: 'return' }): IRFunction {
-  return {
-    name: 'test',
-    params: [],
-    locals: [],
-    blocks: [{ label: 'entry', instrs, term }],
-  }
-}
-
-describe('constantFolding', () => {
-  it('folds 2 + 3 → 5', () => {
-    const fn = makeFn([
-      { op: 'binop', dst: '$x', lhs: { kind: 'const', value: 2 }, bop: '+', rhs: { kind: 'const', value: 3 } },
-    ])
-    const opt = constantFolding(fn)
-    expect(opt.blocks[0].instrs[0]).toEqual({
-      op: 'assign', dst: '$x', src: { kind: 'const', value: 5 },
-    })
-  })
-
-  it('folds 10 / 3 → 3 (truncated int division)', () => {
-    const fn = makeFn([
-      { op: 'binop', dst: '$x', lhs: { kind: 'const', value: 10 }, bop: '/', rhs: { kind: 'const', value: 3 } },
-    ])
-    const opt = constantFolding(fn)
-    expect((opt.blocks[0].instrs[0] as any).src.value).toBe(3)
-  })
-
-  it('folds cmp 5 == 5 → 1', () => {
-    const fn = makeFn([
-      { op: 'cmp', dst: '$r', lhs: { kind: 'const', value: 5 }, cop: '==', rhs: { kind: 'const', value: 5 } },
-    ])
-    const opt = constantFolding(fn)
-    expect((opt.blocks[0].instrs[0] as any).src.value).toBe(1)
-  })
-
-  it('folds cmp 5 > 10 → 0', () => {
-    const fn = makeFn([
-      { op: 'cmp', dst: '$r', lhs: { kind: 'const', value: 5 }, cop: '>', rhs: { kind: 'const', value: 10 } },
-    ])
-    const opt = constantFolding(fn)
-    expect((opt.blocks[0].instrs[0] as any).src.value).toBe(0)
-  })
-
-  it('does not fold division by zero', () => {
-    const fn = makeFn([
-      { op: 'binop', dst: '$x', lhs: { kind: 'const', value: 5 }, bop: '/', rhs: { kind: 'const', value: 0 } },
-    ])
-    const opt = constantFolding(fn)
-    expect(opt.blocks[0].instrs[0].op).toBe('binop')
-  })
-})
-
-describe('copyPropagation', () => {
-  it('propagates simple copy', () => {
-    const fn = makeFn([
-      { op: 'assign', dst: '$t0', src: { kind: 'var', name: '$x' } },
-      { op: 'binop', dst: '$y', lhs: { kind: 'var', name: '$t0' }, bop: '+', rhs: { kind: 'const', value: 1 } },
-    ])
-    const opt = copyPropagation(fn)
-    const binop = opt.blocks[0].instrs[1] as any
-    expect(binop.lhs).toEqual({ kind: 'var', name: '$x' })
-  })
-
-  it('propagates constant copies', () => {
-    const fn = makeFn([
-      { op: 'assign', dst: '$t0', src: { kind: 'const', value: 42 } },
-      { op: 'assign', dst: '$y', src: { kind: 'var', name: '$t0' } },
-    ])
-    const opt = copyPropagation(fn)
-    const second = opt.blocks[0].instrs[1] as any
-    expect(second.src).toEqual({ kind: 'const', value: 42 })
-  })
-})
-
-describe('deadCodeElimination', () => {
-  it('removes unused assignment', () => {
-    const fn = makeFn([
-      { op: 'assign', dst: '$t0', src: { kind: 'const', value: 99 } },  // unused temp
-      { op: 'assign', dst: '$t1', src: { kind: 'const', value: 1 } },   // used temp
-    ], { op: 'return', value: { kind: 'var', name: '$t1' } })
-    const opt = deadCodeElimination(fn)
-    expect(opt.blocks[0].instrs).toHaveLength(1)
-    expect((opt.blocks[0].instrs[0] as any).dst).toBe('$t1')
-  })
-
-  it('keeps call even if return value unused (side effects)', () => {
-    const fn = makeFn([
-      { op: 'call', fn: 'foo', args: [], dst: '$unused' },
-    ])
-    const opt = deadCodeElimination(fn)
-    expect(opt.blocks[0].instrs).toHaveLength(1)
-  })
-
-  it('keeps assignments referenced by raw commands', () => {
-    const fn = makeFn([
-      { op: 'assign', dst: '$used_by_raw', src: { kind: 'const', value: 7 } },
-      { op: 'raw', cmd: 'execute store result score player obj run scoreboard players get $used_by_raw rs' },
-    ])
-    const opt = deadCodeElimination(fn)
-    expect(opt.blocks[0].instrs).toHaveLength(2)
-    expect((opt.blocks[0].instrs[0] as any).dst).toBe('$used_by_raw')
-  })
-})
-
-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)
-    // x = t0      (→ copy prop → x = 5)
-    // unused = 0  (→ DCE → removed)
-    // return x
-    const fn = makeFn([
-      { op: 'binop', dst: '$t0', lhs: { kind: 'const', value: 2 }, bop: '+', rhs: { kind: 'const', value: 3 } },
-      { op: 'assign', dst: '$x', src: { kind: 'var', name: '$t0' } },
-      { op: 'assign', dst: '$t1', src: { kind: 'const', value: 0 } },  // unused temp, should be removed
-    ], { op: 'return', value: { kind: 'var', name: '$x' } })
-
-    const opt = optimize(fn)
-    const instrs = opt.blocks[0].instrs
-    // $t1 (unused temp) should be gone
-    expect(instrs.some((i: any) => i.dst === '$t1')).toBe(false)
-    // $x should be const 5 (after folding + propagation)
-    const xInstr = instrs.find((i: any) => i.dst === '$x') as any
-    expect(xInstr?.src).toEqual({ kind: 'const', value: 5 })
-  })
-})

package/src/__tests__/runtime.test.ts

@@ -1,305 +0,0 @@
-import * as fs from 'fs'
-import * as path from 'path'
-
-import { compile } from '../compile'
-import { MCRuntime, Entity } from '../runtime'
-
-function loadCompiledProgram(source: string, namespace = 'runtime'): MCRuntime {
-  const result = compile(source, { namespace })
-  expect(result.success).toBe(true)
-  expect(result.files).toBeDefined()
-
-  const runtime = new MCRuntime(namespace)
-  for (const file of result.files ?? []) {
-    if (!file.path.endsWith('.mcfunction')) continue
-
-    const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/)
-    if (!match) continue
-
-    const [, ns, fnPath] = match
-    runtime.loadFunction(`${ns}:${fnPath}`, file.content.split('\n'))
-  }
-
-  return runtime
-}
-
-function loadExample(name: string): string {
-  return fs.readFileSync(path.join(__dirname, '..', 'examples', name), 'utf-8')
-}
-
-describe('MCRuntime behavioral integration', () => {
-  it('runs the counter example and increments the scoreboard across ticks', () => {
-    const runtime = loadCompiledProgram(loadExample('counter.mcrs'))
-
-    runtime.load()
-    runtime.ticks(5)
-
-    expect(runtime.getScore('counter', 'ticks')).toBe(5)
-    expect(runtime.tickCount).toBe(5)
-  })
-
-  it('executes compiled math control flow and stores the expected result', () => {
-    const runtime = loadCompiledProgram(`
-fn compute() {
-    let x: int = 3;
-    let result: int = 0;
-
-    if (x > 2) {
-        result = 11;
-    } else {
-        result = 29;
-    }
-
-    scoreboard_set("math", "result", result);
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('compute')
-
-    expect(runtime.getScore('math', 'runtime.result')).toBe(11)
-  })
-
-  it('captures say, announce, actionbar, and title output in the chat log', () => {
-    const runtime = loadCompiledProgram(`
-fn chat() {
-    say("hello");
-    announce("broadcast");
-    actionbar(@a, "warning");
-    title(@a, "Boss Wave");
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('chat')
-
-    expect(runtime.getChatLog()).toEqual([
-      '[Server] hello',
-      'broadcast',
-      '[ACTIONBAR] warning',
-      '[TITLE] Boss Wave',
-    ])
-  })
-
-  it('renders interpolated strings through tellraw score components', () => {
-    const runtime = loadCompiledProgram(`
-fn chat() {
-    let score: int = 7;
-    say("You have \${score} points");
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('chat')
-
-    expect(runtime.getChatLog()).toEqual([
-      'You have 7 points',
-    ])
-  })
-
-  it('renders f-strings through tellraw score components', () => {
-    const runtime = loadCompiledProgram(`
-fn chat() {
-    let score: int = 7;
-    say(f"You have {score} points");
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('chat')
-
-    expect(runtime.getChatLog()).toEqual([
-      'You have 7 points',
-    ])
-  })
-
-  it('kills only entities matched by a foreach selector', () => {
-    const runtime = loadCompiledProgram(`
-fn purge_zombies() {
-    foreach (z in @e[type=zombie]) {
-        kill(z);
-    }
-}
-`)
-
-    const zombieA = runtime.spawnEntity(['hostile'], 'minecraft:zombie')
-    const zombieB = runtime.spawnEntity(['hostile'], 'zombie')
-    const skeleton = runtime.spawnEntity(['hostile'], 'minecraft:skeleton')
-
-    runtime.load()
-    runtime.execFunction('purge_zombies')
-
-    expect(runtime.entities.map(entity => entity.id)).toEqual([skeleton.id])
-    expect(runtime.entities.find(entity => entity.id === zombieA.id)).toBeUndefined()
-    expect(runtime.entities.find(entity => entity.id === zombieB.id)).toBeUndefined()
-  })
-
-  it('executes array push, pop, and len through storage operations', () => {
-    const runtime = loadCompiledProgram(`
-fn arrays() {
-    let arr: int[] = [];
-    arr.push(4);
-    arr.push(9);
-    let popped: int = arr.pop();
-    let len: int = arr.len;
-
-    scoreboard_set("arrays", "len", len);
-    scoreboard_set("arrays", "last", popped);
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('arrays')
-
-    expect(runtime.getScore('arrays', 'runtime.len')).toBe(1)
-    expect(runtime.getScore('arrays', 'runtime.last')).toBe(9)
-    expect(runtime.getStorage('rs:heap.arr')).toEqual([4])
-  })
-
-  it('tracks world state, weather, and time from compiled world commands', () => {
-    const runtime = loadCompiledProgram(`
-fn reset_world() {
-    let floor_start: BlockPos = (0, 64, 0);
-    let floor_end: BlockPos = (1, 64, 1);
-    let centerpiece: BlockPos = (1, 64, 1);
-    fill(floor_start, floor_end, "minecraft:stone");
-    setblock(centerpiece, "minecraft:gold_block");
-    weather("rain");
-    time_set("noon");
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('reset_world')
-
-    expect(runtime.world.get('0,64,0')).toBe('minecraft:stone')
-    expect(runtime.world.get('0,64,1')).toBe('minecraft:stone')
-    expect(runtime.world.get('1,64,0')).toBe('minecraft:stone')
-    expect(runtime.world.get('1,64,1')).toBe('minecraft:gold_block')
-    expect(runtime.weather).toBe('rain')
-    expect(runtime.worldTime).toBe(6000)
-  })
-
-  it('respects @tick(rate=5) scheduling when ticking the runtime', () => {
-    const runtime = loadCompiledProgram(`
-@tick(rate=5)
-fn pulse() {
-    let count: int = scoreboard_get("pulse", "count");
-    count = count + 1;
-    scoreboard_set("pulse", "count", count);
-}
-`)
-
-    runtime.load()
-    runtime.ticks(10)
-
-    expect(runtime.getScore('pulse', 'runtime.count')).toBe(2)
-  })
-
-  it('executes only the matching match arm', () => {
-    const runtime = loadCompiledProgram(`
-fn choose() {
-    let choice: int = 2;
-    match (choice) {
-        1 => { say("one"); }
-        2 => { say("two"); }
-        _ => { say("other"); }
-    }
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('choose')
-
-    expect(runtime.getChatLog()).toEqual([
-      '[Server] two',
-    ])
-  })
-
-  it('updates position, effects, and xp for executor-targeted builtins', () => {
-    const runtime = loadCompiledProgram(`
-fn buff_player() {
-    tp(@s, (5, 70, -2));
-    effect(@s, "speed", 15, 2);
-    xp_add(@s, 5);
-    xp_set(@s, 12, "levels");
-}
-`)
-
-    const player: Entity = runtime.spawnEntity(['player'], 'minecraft:player')
-
-    runtime.load()
-    runtime.execFunction('buff_player', player)
-
-    expect(player.position).toEqual({ x: 5, y: 70, z: -2 })
-    expect(runtime.effects.get(player.id)).toEqual([
-      { effect: 'speed', duration: 15, amplifier: 2 },
-    ])
-    expect(runtime.xp.get(player.id)).toBe(12)
-  })
-
-  it('executes lambda variables through generated sub-functions', () => {
-    const runtime = loadCompiledProgram(`
-fn test() {
-    let double: (int) -> int = (x: int) => x * 2;
-    let result: int = double(5);
-    scoreboard_set("lambda", "direct", result);
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('test')
-
-    expect(runtime.getScore('lambda', 'runtime.direct')).toBe(10)
-  })
-
-  it('executes lambdas passed as callback arguments', () => {
-    const runtime = loadCompiledProgram(`
-fn apply(val: int, cb: (int) -> int) -> int {
-    return cb(val);
-}
-
-fn test() {
-    let result: int = apply(5, (x: int) => x * 3);
-    scoreboard_set("lambda", "callback", result);
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('test')
-
-    expect(runtime.getScore('lambda', 'runtime.callback')).toBe(15)
-  })
-
-  it('executes block-body lambdas', () => {
-    const runtime = loadCompiledProgram(`
-fn test() {
-    let process: (int) -> int = (x: int) => {
-        let doubled: int = x * 2;
-        return doubled + 1;
-    };
-    let result: int = process(5);
-    scoreboard_set("lambda", "block", result);
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('test')
-
-    expect(runtime.getScore('lambda', 'runtime.block')).toBe(11)
-  })
-
-  it('executes immediately-invoked expression-body lambdas', () => {
-    const runtime = loadCompiledProgram(`
-fn test() {
-    let result: int = ((x: int) => x * 2)(5);
-    scoreboard_set("lambda", "iife", result);
-}
-`)
-
-    runtime.load()
-    runtime.execFunction('test')
-
-    expect(runtime.getScore('lambda', 'runtime.iife')).toBe(10)
-  })
-})