redscript-mc 1.2.30 → 2.1.0

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

package/src/__tests__/sourcemap.test.ts

@@ -0,0 +1,254 @@
+/**
+ * Source Map Tests — Phase 4a
+ *
+ * Verifies that generated .sourcemap.json files correctly map output lines
+ * back to source .mcrs locations.
+ */
+
+import { compile } from '../index'
+import type { SourceMap } from '../emit/sourcemap'
+
+function getSourceMap(
+  files: ReturnType<typeof compile>['files'],
+  fnSuffix: string,
+): SourceMap {
+  const smPath = `data/test/function/${fnSuffix}.sourcemap.json`
+  const file = files.find(f => f.path === smPath)
+  if (!file) {
+    const paths = files.map(f => f.path).join(', ')
+    throw new Error(`Missing sourcemap: ${smPath}\nAvailable: ${paths}`)
+  }
+  return JSON.parse(file.content) as SourceMap
+}
+
+function getMcFunction(
+  files: ReturnType<typeof compile>['files'],
+  fnSuffix: string,
+): string {
+  const mcPath = `data/test/function/${fnSuffix}.mcfunction`
+  const file = files.find(f => f.path === mcPath)
+  if (!file) throw new Error(`Missing mcfunction: ${mcPath}`)
+  return file.content
+}
+
+// ---------------------------------------------------------------------------
+// Basic structure
+// ---------------------------------------------------------------------------
+
+describe('source map — basic structure', () => {
+  it('generates sourcemap.json only when generateSourceMap=true', () => {
+    const source = `fn add(a: int, b: int): int { return a + b; }`
+    const without = compile(source, { namespace: 'test', filePath: 'src/add.mcrs' })
+    expect(without.files.some(f => f.path.endsWith('.sourcemap.json'))).toBe(false)
+
+    const with_ = compile(source, { namespace: 'test', generateSourceMap: true, filePath: 'src/add.mcrs' })
+    expect(with_.files.some(f => f.path.endsWith('.sourcemap.json'))).toBe(true)
+  })
+
+  it('sourcemap has version=1', () => {
+    const source = `fn greet() { say("hello"); }`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/greet.mcrs',
+    })
+    const sm = getSourceMap(result.files, 'greet')
+    expect(sm.version).toBe(1)
+  })
+
+  it('sourcemap generatedFile matches the mcfunction path', () => {
+    const source = `fn foo() { say("x"); }`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/foo.mcrs',
+    })
+    const sm = getSourceMap(result.files, 'foo')
+    expect(sm.generatedFile).toBe('data/test/function/foo.mcfunction')
+  })
+
+  it('sources array contains the source file path', () => {
+    const source = `fn bar() { say("y"); }`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/bar.mcrs',
+    })
+    const sm = getSourceMap(result.files, 'bar')
+    expect(sm.sources).toContain('src/bar.mcrs')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Mapping correctness
+// ---------------------------------------------------------------------------
+
+describe('source map — mapping correctness', () => {
+  it('each mapping line references a valid output line', () => {
+    const source = `
+fn simple(x: int): int {
+  let y = x + 1;
+  return y;
+}
+`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/simple.mcrs',
+    })
+    const sm = getSourceMap(result.files, 'simple')
+    const mcfn = getMcFunction(result.files, 'simple')
+    const outputLines = mcfn.split('\n').filter(l => l.length > 0)
+
+    for (const mapping of sm.mappings) {
+      expect(mapping.line).toBeGreaterThanOrEqual(1)
+      expect(mapping.line).toBeLessThanOrEqual(outputLines.length)
+      expect(mapping.sourceLine).toBeGreaterThanOrEqual(1)
+      expect(mapping.sourceCol).toBeGreaterThanOrEqual(1)
+    }
+  })
+
+  it('source index in mappings refers to valid sources entry', () => {
+    const source = `fn calc(a: int, b: int): int { return a * b; }`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/calc.mcrs',
+    })
+    const sm = getSourceMap(result.files, 'calc')
+    for (const m of sm.mappings) {
+      expect(m.source).toBeGreaterThanOrEqual(0)
+      expect(m.source).toBeLessThan(sm.sources.length)
+    }
+  })
+
+  it('mappings cover the output lines from a simple function body', () => {
+    const source = `
+fn add(a: int, b: int): int {
+  return a + b;
+}
+`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/add.mcrs',
+    })
+    const sm = getSourceMap(result.files, 'add')
+    // There should be at least one mapping
+    expect(sm.mappings.length).toBeGreaterThan(0)
+    // All mappings should point at non-zero source lines
+    for (const m of sm.mappings) {
+      expect(m.sourceLine).toBeGreaterThan(0)
+    }
+  })
+
+  it('sourceLine values are ordered and correspond to source line numbers', () => {
+    const source = `
+fn multi() {
+  let a = 1;
+  let b = 2;
+  let c = a + b;
+  say("hello");
+}
+`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/multi.mcrs',
+    })
+    const sm = getSourceMap(result.files, 'multi')
+    // All mapped source lines should be in the range of the function body
+    for (const m of sm.mappings) {
+      expect(m.sourceLine).toBeGreaterThanOrEqual(2) // fn starts at line 2
+      expect(m.sourceLine).toBeLessThanOrEqual(8)    // fn ends at line 8
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// No sourcemap when no filePath
+// ---------------------------------------------------------------------------
+
+describe('source map — no filePath', () => {
+  it('generates sourcemap with empty sources when no filePath is provided', () => {
+    const source = `fn noloc() { say("no file"); }`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      // no filePath
+    })
+    // Source map should not be generated (no sourceLoc info to record)
+    const hasSm = result.files.some(f => f.path.endsWith('.sourcemap.json'))
+    // Either no sourcemap generated, or it has empty mappings
+    if (hasSm) {
+      const sm = getSourceMap(result.files, 'noloc')
+      expect(sm.mappings.length).toBe(0)
+    }
+    // This is acceptable either way — just verify it doesn't crash
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Nested function calls
+// ---------------------------------------------------------------------------
+
+describe('source map — nested function calls', () => {
+  it('each function gets its own sourcemap', () => {
+    const source = `
+fn helper(x: int): int {
+  return x * 2;
+}
+
+fn caller() {
+  let r = helper(5);
+  say("done");
+}
+`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/nested.mcrs',
+    })
+    // Both functions should have sourcemaps
+    const helperSm = getSourceMap(result.files, 'helper')
+    const callerSm = getSourceMap(result.files, 'caller')
+
+    expect(helperSm.mappings.length).toBeGreaterThan(0)
+    expect(callerSm.mappings.length).toBeGreaterThan(0)
+
+    // helper's mappings should reference lines 2-4
+    for (const m of helperSm.mappings) {
+      expect(m.sourceLine).toBeGreaterThanOrEqual(2)
+      expect(m.sourceLine).toBeLessThanOrEqual(4)
+    }
+
+    // caller's mappings should reference lines 7-9
+    for (const m of callerSm.mappings) {
+      expect(m.sourceLine).toBeGreaterThanOrEqual(7)
+      expect(m.sourceLine).toBeLessThanOrEqual(9)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// sourcemap.json sidecar path
+// ---------------------------------------------------------------------------
+
+describe('source map — file path convention', () => {
+  it('sourcemap path replaces .mcfunction with .sourcemap.json', () => {
+    const source = `fn test_fn() { say("test"); }`
+    const result = compile(source, {
+      namespace: 'test',
+      generateSourceMap: true,
+      filePath: 'src/test.mcrs',
+    })
+    const smFiles = result.files.filter(f => f.path.endsWith('.sourcemap.json'))
+    expect(smFiles.length).toBeGreaterThan(0)
+    for (const sf of smFiles) {
+      expect(sf.path).toMatch(/\.sourcemap\.json$/)
+      // Corresponding .mcfunction should also exist
+      const mcPath = sf.path.replace('.sourcemap.json', '.mcfunction')
+      expect(result.files.some(f => f.path === mcPath)).toBe(true)
+    }
+  })
+})