redscript-mc 2.0.0 → 2.1.1

package/src/__tests__/optimizer/unroll.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Tests for the small constant loop unrolling pass.
+ *
+ * We test through the full compiler pipeline (source → MIR → optimize)
+ * to verify realistic unroll behavior, and also test the pass directly
+ * with synthetic MIR for edge cases.
+ */
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { optimizeFunction } from '../../optimizer/pipeline'
+import { loopUnroll } from '../../optimizer/unroll'
+import type { MIRFunction, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+function compileToMIR(source: string): MIRFunction[] {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  const hir = lowerToHIR(ast)
+  const mir = lowerToMIR(hir)
+  return mir.functions
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr, preds: string[] = []): MIRBlock {
+  return { id, instrs, term, preds }
+}
+
+function mkFn(blocks: MIRBlock[]): MIRFunction {
+  return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false }
+}
+
+const c = (v: number): Operand => ({ kind: 'const', value: v })
+const t = (n: string): Operand => ({ kind: 'temp', name: n })
+
+// ---------------------------------------------------------------------------
+// Synthetic MIR tests
+// ---------------------------------------------------------------------------
+
+describe('loopUnroll — synthetic MIR', () => {
+  /**
+   * Build a minimal for(i=0; i<N; i++) loop in MIR form:
+   *   entry: const i 0; jump → loop_header
+   *   loop_header: cmp t_cmp lt i N; branch t_cmp → loop_body / loop_exit
+   *   loop_body: [body instrs]; jump → loop_latch
+   *   loop_latch: add i i 1; jump → loop_header
+   *   loop_exit: return null
+   */
+  function buildLoop(N: number, bodyInstrs: MIRInstr[]): MIRFunction {
+    return mkFn([
+      mkBlock('entry', [
+        { kind: 'const', dst: 'i', value: 0 },
+      ], { kind: 'jump', target: 'loop_header_0' }),
+      mkBlock('loop_header_0', [
+        { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(N) },
+      ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+      mkBlock('loop_body_0', bodyInstrs, { kind: 'jump', target: 'loop_latch_0' }),
+      mkBlock('loop_latch_0', [
+        { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+      ], { kind: 'jump', target: 'loop_header_0' }),
+      mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+    ])
+  }
+
+  test('for(i=0; i<3; i++) unrolls to 3 copies of body', () => {
+    const bodyInstrs: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(3, bodyInstrs)
+    const result = loopUnroll(fn)
+
+    // loop_header, loop_body, loop_latch should be gone
+    expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false)
+    expect(result.blocks.some(b => b.id.startsWith('loop_latch'))).toBe(false)
+    expect(result.blocks.some(b => b.id.startsWith('loop_body'))).toBe(false)
+
+    // loop_exit should still be there
+    expect(result.blocks.some(b => b.id.startsWith('loop_exit'))).toBe(true)
+
+    // entry block should contain 3 call instructions with substituted i values
+    const entry = result.blocks.find(b => b.id === 'entry')!
+    const calls = entry.instrs.filter(instr => instr.kind === 'call')
+    expect(calls).toHaveLength(3)
+
+    // Each call should have i substituted as 0, 1, 2
+    expect((calls[0] as Extract<MIRInstr, { kind: 'call' }>).args[0]).toEqual(c(0))
+    expect((calls[1] as Extract<MIRInstr, { kind: 'call' }>).args[0]).toEqual(c(1))
+    expect((calls[2] as Extract<MIRInstr, { kind: 'call' }>).args[0]).toEqual(c(2))
+  })
+
+  test('for(i=0; i<1; i++) unrolls to 1 copy', () => {
+    const bodyInstrs: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(1, bodyInstrs)
+    const result = loopUnroll(fn)
+
+    const entry = result.blocks.find(b => b.id === 'entry')!
+    const calls = entry.instrs.filter(instr => instr.kind === 'call')
+    expect(calls).toHaveLength(1)
+    expect((calls[0] as Extract<MIRInstr, { kind: 'call' }>).args[0]).toEqual(c(0))
+  })
+
+  test('for(i=0; i<8; i++) unrolls to 8 copies (at limit)', () => {
+    const bodyInstrs: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(8, bodyInstrs)
+    const result = loopUnroll(fn)
+
+    const entry = result.blocks.find(b => b.id === 'entry')!
+    const calls = entry.instrs.filter(instr => instr.kind === 'call')
+    expect(calls).toHaveLength(8)
+  })
+
+  test('for(i=0; i<9; i++) does NOT unroll (exceeds limit)', () => {
+    const bodyInstrs: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(9, bodyInstrs)
+    const result = loopUnroll(fn)
+
+    // Should not have changed — loop blocks remain
+    expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true)
+    expect(result).toBe(fn)
+  })
+
+  test('for(i=0; i<10; i++) does NOT unroll', () => {
+    const bodyInstrs: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(10, bodyInstrs)
+    const result = loopUnroll(fn)
+    expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true)
+  })
+
+  test('variable substitution replaces i in arithmetic', () => {
+    // Body: x = i * 2
+    const bodyInstrs: MIRInstr[] = [
+      { kind: 'mul', dst: 'x', a: t('i'), b: c(2) },
+      { kind: 'call', dst: null, fn: 'test:use', args: [t('x')] },
+    ]
+    const fn = buildLoop(3, bodyInstrs)
+    const result = loopUnroll(fn)
+
+    const entry = result.blocks.find(b => b.id === 'entry')!
+    const muls = entry.instrs.filter(instr => instr.kind === 'mul') as Extract<MIRInstr, { kind: 'mul' }>[]
+    expect(muls).toHaveLength(3)
+    expect(muls[0].a).toEqual(c(0))
+    expect(muls[1].a).toEqual(c(1))
+    expect(muls[2].a).toEqual(c(2))
+  })
+
+  test('init must be 0 — does not unroll if initialized to non-zero', () => {
+    // entry: const i 1 (not 0)
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'const', dst: 'i', value: 1 },
+      ], { kind: 'jump', target: 'loop_header_0' }),
+      mkBlock('loop_header_0', [
+        { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(3) },
+      ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+      mkBlock('loop_body_0', [
+        { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+      ], { kind: 'jump', target: 'loop_latch_0' }),
+      mkBlock('loop_latch_0', [
+        { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+      ], { kind: 'jump', target: 'loop_header_0' }),
+      mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+    ])
+    const result = loopUnroll(fn)
+    expect(result).toBe(fn)
+  })
+
+  test('non-lt comparison does not unroll', () => {
+    // loop_header: cmp le (not lt)
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'const', dst: 'i', value: 0 },
+      ], { kind: 'jump', target: 'loop_header_0' }),
+      mkBlock('loop_header_0', [
+        { kind: 'cmp', dst: 't_cmp', op: 'le', a: t('i'), b: c(3) },
+      ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+      mkBlock('loop_body_0', [
+        { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+      ], { kind: 'jump', target: 'loop_latch_0' }),
+      mkBlock('loop_latch_0', [
+        { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+      ], { kind: 'jump', target: 'loop_header_0' }),
+      mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+    ])
+    const result = loopUnroll(fn)
+    expect(result).toBe(fn)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// End-to-end tests via full compiler pipeline
+// ---------------------------------------------------------------------------
+
+describe('loopUnroll — end-to-end via optimizeFunction', () => {
+  test('for(0..3) loop is unrolled after full optimization', () => {
+    const fns = compileToMIR(`
+      fn f(): void {
+        for (let i: int = 0; i < 3; i = i + 1) {
+          cmd("say " + i);
+        }
+      }
+    `)
+    const fn = fns[0]
+    const optimized = optimizeFunction(fn)
+
+    // After optimization, loop blocks should be gone
+    expect(optimized.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false)
+    expect(optimized.blocks.some(b => b.id.startsWith('loop_latch'))).toBe(false)
+  })
+
+  test('for(0..10) loop is NOT unrolled', () => {
+    const fns = compileToMIR(`
+      fn f(): void {
+        for (let i: int = 0; i < 10; i = i + 1) {
+          cmd("say " + i);
+        }
+      }
+    `)
+    const fn = fns[0]
+    const optimized = optimizeFunction(fn)
+
+    // Loop blocks should remain (N=10 > limit)
+    expect(optimized.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true)
+  })
+})

package/src/__tests__/option.test.ts

@@ -0,0 +1,299 @@
+/**
+ * Tests for Phase 6a: Option<T> — null safety
+ *
+ * Covers:
+ * - Parsing Option<T> type annotation
+ * - Parsing Some(expr) and None expressions
+ * - Parsing if let Some(x) = opt { ... }
+ * - HIR lowering of Option nodes
+ * - MIR lowering: Option compiles to two slots (has + val)
+ * - if let Some(x) = opt → checks has slot, binds val slot
+ * - Function returning Option<int>
+ * - Correct scoreboard commands generated
+ */
+
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { compile } from '../emit/compile'
+import { lowerToHIR } from '../hir/lower'
+import type { Program } from '../ast/types'
+
+function parse(source: string, namespace = 'test'): Program {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens).parse(namespace)
+}
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  // Prefer exact function file match: look for function/<name>.mcfunction
+  const exact = files.find(f => f.path.endsWith(`function/${pathSubstr}.mcfunction`))
+  if (exact) return exact.content
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+// ---------------------------------------------------------------------------
+// Parser tests
+// ---------------------------------------------------------------------------
+
+describe('Option: Parser', () => {
+  it('parses Option<int> type annotation', () => {
+    const prog = parse('fn f(): Option<int> {}')
+    expect(prog.declarations[0].returnType).toEqual({ kind: 'option', inner: { kind: 'named', name: 'int' } })
+  })
+
+  it('parses Option<bool> parameter type', () => {
+    const prog = parse('fn f(x: Option<bool>): void {}')
+    expect(prog.declarations[0].params[0].type).toEqual({ kind: 'option', inner: { kind: 'named', name: 'bool' } })
+  })
+
+  it('parses Some(42) expression', () => {
+    const prog = parse('fn f(): void { let x: Option<int> = Some(42); }')
+    const letStmt = prog.declarations[0].body[0]
+    expect(letStmt.kind).toBe('let')
+    if (letStmt.kind === 'let') {
+      expect(letStmt.init.kind).toBe('some_lit')
+      if (letStmt.init.kind === 'some_lit') {
+        expect(letStmt.init.value).toEqual({ kind: 'int_lit', value: 42 })
+      }
+    }
+  })
+
+  it('parses None expression', () => {
+    const prog = parse('fn f(): void { let x: Option<int> = None; }')
+    const letStmt = prog.declarations[0].body[0]
+    expect(letStmt.kind).toBe('let')
+    if (letStmt.kind === 'let') {
+      expect(letStmt.init.kind).toBe('none_lit')
+    }
+  })
+
+  it('parses if let Some(x) = opt { ... }', () => {
+    const prog = parse('fn f(p: Option<int>): void { if let Some(x) = p { let y: int = x; } }')
+    const stmt = prog.declarations[0].body[0]
+    expect(stmt.kind).toBe('if_let_some')
+    if (stmt.kind === 'if_let_some') {
+      expect(stmt.binding).toBe('x')
+      expect(stmt.init).toEqual({ kind: 'ident', name: 'p' })
+      expect(stmt.then.length).toBe(1)
+    }
+  })
+
+  it('parses if let Some(x) = opt { } else { }', () => {
+    const prog = parse(`
+      fn f(p: Option<int>): void {
+        if let Some(x) = p {
+          let a: int = x;
+        } else {
+          let b: int = 0;
+        }
+      }
+    `)
+    const stmt = prog.declarations[0].body[0]
+    expect(stmt.kind).toBe('if_let_some')
+    if (stmt.kind === 'if_let_some') {
+      expect(stmt.else_).toBeDefined()
+      expect(stmt.else_!.length).toBe(1)
+    }
+  })
+
+  it('does not treat Some as identifier', () => {
+    const prog = parse('fn f(): void { let x: Option<int> = Some(1); }')
+    if (prog.declarations[0].body[0].kind === 'let') {
+      const init = prog.declarations[0].body[0].init
+      expect(init.kind).toBe('some_lit')
+    }
+  })
+
+  it('does not treat None as identifier', () => {
+    const prog = parse('fn f(): void { let x: Option<int> = None; }')
+    if (prog.declarations[0].body[0].kind === 'let') {
+      const init = prog.declarations[0].body[0].init
+      expect(init.kind).toBe('none_lit')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// HIR lowering tests
+// ---------------------------------------------------------------------------
+
+describe('Option: HIR lowering', () => {
+  function hirOf(source: string) {
+    const tokens = new Lexer(source).tokenize()
+    const ast = new Parser(tokens).parse('test')
+    return lowerToHIR(ast)
+  }
+
+  it('lowers some_lit through HIR unchanged', () => {
+    const hir = hirOf('fn f(): void { let x: Option<int> = Some(42); }')
+    const fn0 = hir.functions[0]
+    const letStmt = fn0.body[0]
+    expect(letStmt.kind).toBe('let')
+    if (letStmt.kind === 'let') {
+      expect(letStmt.init.kind).toBe('some_lit')
+    }
+  })
+
+  it('lowers none_lit through HIR unchanged', () => {
+    const hir = hirOf('fn f(): void { let x: Option<int> = None; }')
+    const fn0 = hir.functions[0]
+    const letStmt = fn0.body[0]
+    expect(letStmt.kind).toBe('let')
+    if (letStmt.kind === 'let') {
+      expect(letStmt.init.kind).toBe('none_lit')
+    }
+  })
+
+  it('lowers if_let_some through HIR unchanged', () => {
+    const hir = hirOf('fn f(p: Option<int>): void { if let Some(x) = p {} }')
+    const fn0 = hir.functions[0]
+    const stmt = fn0.body[0]
+    expect(stmt.kind).toBe('if_let_some')
+    if (stmt.kind === 'if_let_some') {
+      expect(stmt.binding).toBe('x')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Compilation (E2E) tests
+// ---------------------------------------------------------------------------
+
+describe('Option: E2E compilation', () => {
+  it('compiles Some(42) assignment — sets has=1, val=42', () => {
+    const source = `
+      fn test(): void {
+        let p: Option<int> = Some(42);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'test')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('scoreboard players set')
+    // has slot should be set to 1, val slot should be set to 42
+    expect(fn).toContain('1')
+    expect(fn).toContain('42')
+  })
+
+  it('compiles None assignment — sets has=0', () => {
+    const source = `
+      fn test(): void {
+        let p: Option<int> = None;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'test')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('scoreboard players set')
+    expect(fn).toContain('0')
+  })
+
+  it('compiles if let Some(x) = p — conditional on has slot', () => {
+    const source = `
+      fn test(p: Option<int>): void {
+        if let Some(x) = p {
+          let y: int = x;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    // Should generate a conditional call checking has slot
+    expect(result.files.length).toBeGreaterThan(0)
+  })
+
+  it('compiles function returning Option<int> Some value', () => {
+    const source = `
+      fn make_some(): Option<int> {
+        return Some(99);
+      }
+      fn test(): void {
+        let p: Option<int> = make_some();
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'make_some')
+    expect(fn).toBeDefined()
+    // Should set ret_has=1 and ret_val=99
+    expect(fn).toContain('$ret_has')
+    expect(fn).toContain('99')
+  })
+
+  it('compiles function returning Option<int> None value', () => {
+    const source = `
+      fn make_none(): Option<int> {
+        return None;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'make_none')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('$ret_has')
+    // has=0
+    expect(fn).toContain('0')
+  })
+
+  it('compiles full if-let Some pattern with body using bound variable', () => {
+    // Use a function that returns Option<int> so the condition is not constant-folded
+    const source = `
+      fn maybe_val(): Option<int> {
+        return Some(10);
+      }
+      @tick
+      fn tick(): void {
+        let p: Option<int> = maybe_val();
+        if let Some(n) = p {
+          let doubled: int = n + n;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+    // Verify a conditional function split was created
+    const hasConditional = result.files.some(f => f.content.includes('execute if score'))
+    expect(hasConditional).toBe(true)
+  })
+
+  it('compiles if-let with else branch', () => {
+    const source = `
+      @tick
+      fn tick(): void {
+        let q: Option<int> = None;
+        if let Some(v) = q {
+          let a: int = v;
+        } else {
+          let b: int = 0;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+  })
+
+  it('compiles nested if-let inside if-let', () => {
+    const source = `
+      fn test(): void {
+        let a: Option<int> = Some(1);
+        let b: Option<int> = Some(2);
+        if let Some(x) = a {
+          if let Some(y) = b {
+            let sum: int = x + y;
+          }
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+  })
+
+  it('generated scoreboard slots are unique per function and variable', () => {
+    const source = `
+      fn test(): void {
+        let p: Option<int> = Some(5);
+        let q: Option<int> = None;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'test')
+    expect(fn).toBeDefined()
+  })
+})

package/src/__tests__/schedule.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests for @schedule decorator (Phase 5c)
+ *
+ * @schedule(ticks=N) generates a _schedule_xxx.mcfunction wrapper that
+ * emits `schedule function ns:xxx Nt`.
+ */
+
+import { compile } from '../emit/compile'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+describe('@schedule decorator', () => {
+  test('@schedule(ticks=20) generates _schedule wrapper with 20t', () => {
+    const source = `
+      @schedule(ticks=20)
+      fn after_one_second(): void {
+        say("One second passed!");
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const wrapper = getFile(result.files, '_schedule_after_one_second.mcfunction')
+    expect(wrapper).toBeDefined()
+    expect(wrapper).toBe('schedule function test:after_one_second 20t\n')
+  })
+
+  test('@schedule(ticks=1) generates _schedule wrapper with 1t', () => {
+    const source = `
+      @schedule(ticks=1)
+      fn next_tick(): void {
+        say("next tick!");
+      }
+    `
+    const result = compile(source, { namespace: 'ns' })
+    const wrapper = getFile(result.files, '_schedule_next_tick.mcfunction')
+    expect(wrapper).toBeDefined()
+    expect(wrapper).toBe('schedule function ns:next_tick 1t\n')
+  })
+
+  test('@schedule does not affect tick.json', () => {
+    const source = `
+      @schedule(ticks=20)
+      fn deferred(): void {
+        say("deferred");
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const tickJson = getFile(result.files, 'tick.json')
+    expect(tickJson).toBeUndefined()
+  })
+
+  test('@schedule coexists with @tick and @load', () => {
+    const source = `
+      @tick
+      fn game_tick(): void {
+        let x: int = 1;
+      }
+
+      @load
+      fn init(): void {
+        let y: int = 0;
+      }
+
+      @schedule(ticks=40)
+      fn two_seconds(): void {
+        say("two seconds!");
+      }
+    `
+    const result = compile(source, { namespace: 'combo' })
+
+    // @tick still works
+    const tickJson = getFile(result.files, 'tick.json')
+    expect(tickJson).toBeDefined()
+    expect(JSON.parse(tickJson!).values).toContain('combo:game_tick')
+
+    // @load still works
+    const loadJson = getFile(result.files, 'load.json')
+    expect(loadJson).toBeDefined()
+    expect(JSON.parse(loadJson!).values).toContain('combo:init')
+
+    // @schedule generates wrapper
+    const wrapper = getFile(result.files, '_schedule_two_seconds.mcfunction')
+    expect(wrapper).toBeDefined()
+    expect(wrapper).toBe('schedule function combo:two_seconds 40t\n')
+  })
+
+  test('calling _schedule_xxx() invokes the schedule wrapper', () => {
+    const source = `
+      @schedule(ticks=20)
+      fn after_one_second(): void {
+        say("delayed");
+      }
+
+      fn start(): void {
+        _schedule_after_one_second();
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const startFn = getFile(result.files, 'start.mcfunction')
+    expect(startFn).toBeDefined()
+    expect(startFn).toContain('function test:_schedule_after_one_second')
+  })
+})