redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/emit/modules-rewrite.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Coverage for src/emit/modules.ts — rewriteCallsInProgram and rewriteStmt/rewriteExpr
+ *
+ * Targets the rewriting of various AST node types when module imports are resolved:
+ * - while stmt with imported call
+ * - for_range stmt with imported call
+ * - match stmt with imported call in arm
+ * - execute stmt with imported call in body
+ * - let_destruct with imported call
+ * - member/member_assign/index/index_assign expressions using imported fn
+ * - array_lit, struct_lit, tuple_lit with imported fn
+ * - invoke, assign, binary, unary expressions
+ * - implBlock methods are rewritten
+ * - return stmt with value using imported fn
+ * - if stmt with else using imported fn
+ */
+
+import { compileModules } from '../../emit/modules'
+
+function modules(main: string, libBody: string, namespace = 'rw') {
+  return compileModules([
+    {
+      name: 'lib',
+      source: `
+        module lib;
+        export fn helper(): int { return 42; }
+        ${libBody}
+      `,
+    },
+    {
+      name: 'main',
+      source: `
+        import lib::helper;
+        ${main}
+      `,
+    },
+  ], { namespace })
+}
+
+// ── while stmt ─────────────────────────────────────────────────────────────
+
+test('rewrite: while stmt with imported call in cond', () => {
+  const result = modules(`
+    fn entry(): int {
+      while (helper() > 0) {
+        return 1;
+      }
+      return 0;
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── return stmt ─────────────────────────────────────────────────────────────
+
+test('rewrite: return stmt with imported call', () => {
+  const result = modules(`
+    fn entry(): int { return helper(); }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── if with else ────────────────────────────────────────────────────────────
+
+test('rewrite: if stmt with else using imported call', () => {
+  const result = modules(`
+    fn entry(): int {
+      if (helper() > 0) {
+        return 1;
+      } else {
+        return 0;
+      }
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── binary / unary / assign ─────────────────────────────────────────────────
+
+test('rewrite: binary expr with imported call', () => {
+  const result = modules(`
+    fn entry(): int {
+      let x = helper() + helper();
+      return x;
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+test('rewrite: assign expr with imported call', () => {
+  const result = modules(`
+    fn entry(): int {
+      let x = 0;
+      x = helper();
+      return x;
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── member / member_assign ──────────────────────────────────────────────────
+
+test('rewrite: member access with imported call', () => {
+  const result = modules(`
+    struct Wrapper { val: int }
+    fn make(): Wrapper { return Wrapper { val: helper() }; }
+    fn entry(): int {
+      let w = make();
+      return w.val;
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── array_lit ─────────────────────────────────────────────────────────────
+
+test('rewrite: array_lit with imported call', () => {
+  const result = modules(`
+    fn entry(): int {
+      let arr: int[] = [helper(), helper()];
+      return 0;
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── for_range stmt ─────────────────────────────────────────────────────────
+
+test('rewrite: for_range with imported call in bounds', () => {
+  const result = modules(`
+    fn entry(): int {
+      let sum = 0;
+      for i in 0..helper() {
+        sum = sum + i;
+      }
+      return sum;
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── struct_lit ─────────────────────────────────────────────────────────────
+
+test('rewrite: struct_lit with imported call in field', () => {
+  const result = modules(`
+    struct Pair { a: int, b: int }
+    fn entry(): int {
+      let p = Pair { a: helper(), b: 0 };
+      return p.a;
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── impl block methods rewriting ───────────────────────────────────────────
+
+test('rewrite: impl block method uses imported symbol', () => {
+  const result = modules(`
+    struct Calculator { offset: int }
+    impl Calculator {
+      fn compute(self): int {
+        return self.offset + helper();
+      }
+    }
+    fn entry(): int {
+      let c = Calculator { offset: 10 };
+      return c.compute();
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry') || f.path.includes('compute'))).toBe(true)
+})
+
+// ── match stmt ────────────────────────────────────────────────────────────
+
+test('rewrite: match stmt with imported call in arm body', () => {
+  const result = modules(`
+    enum Status { Active, Inactive }
+    fn entry(): int {
+      let s: Status = Status::Active;
+      match s {
+        Status::Active => { return helper(); }
+        Status::Inactive => { return 0; }
+      }
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── execute stmt ─────────────────────────────────────────────────────────
+
+test('rewrite: execute block with imported call', () => {
+  const result = modules(`
+    fn entry(): int {
+      execute as @a run {
+        let x = helper();
+      }
+      return 0;
+    }
+  `, '')
+  expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+})
+
+// ── 3 modules — pack.mcmeta only emitted once ─────────────────────────────
+
+test('pack.mcmeta emitted only once in multi-module output', () => {
+  const result = compileModules([
+    { name: 'a', source: 'module a;\nexport fn fa(): int { return 1; }' },
+    { name: 'b', source: 'module b;\nexport fn fb(): int { return 2; }' },
+    { name: 'main', source: 'import a::fa;\nimport b::fb;\nfn entry(): int { return fa() + fb(); }' },
+  ], { namespace: 'multi' })
+
+  const packMeta = result.files.filter(f => f.path === 'pack.mcmeta')
+  expect(packMeta).toHaveLength(1)
+})
+
+// ── @tick and @load functions in modules ──────────────────────────────────
+
+test('modules with @tick and @load functions emit tick/load tags', () => {
+  const result = compileModules([
+    {
+      name: 'game',
+      source: `
+        module game;
+        @tick
+        fn on_tick(): void { raw("say tick"); }
+      `,
+    },
+  ], { namespace: 'ticked' })
+
+  const tickTag = result.files.find(f => f.path.includes('tick.json'))
+  expect(tickTag).toBeDefined()
+})

package/src/__tests__/emit/source-map.test.ts

@@ -0,0 +1,152 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { compile } from '../../index'
+import type { NamespaceSourceMap, SourceMap } from '../../emit/sourcemap'
+
+function getFile(files: ReturnType<typeof compile>['files'], filePath: string): string {
+  const file = files.find(entry => entry.path === filePath)
+  if (!file) {
+    throw new Error(`Missing file: ${filePath}\nAvailable:\n${files.map(entry => entry.path).join('\n')}`)
+  }
+  return file.content
+}
+
+function compileWithSource(source: string, filePath = 'src/main.mcrs') {
+  return compile(source, {
+    namespace: 'trace',
+    filePath,
+    generateSourceMap: true,
+  })
+}
+
+describe('emit source map output', () => {
+  test('generates namespace sourcemap.json', () => {
+    const result = compileWithSource(`
+fn attack(target: string): void {
+  say(target);
+}
+`)
+
+    const map = JSON.parse(getFile(result.files, 'trace.sourcemap.json')) as NamespaceSourceMap
+    expect(map.version).toBe(1)
+    expect(map.sources).toEqual(['src/main.mcrs'])
+  })
+
+  test('mcfunction files include generated-from and source headers', () => {
+    const result = compileWithSource(`
+fn attack(target: string): void {
+  say(target);
+}
+`)
+
+    const fn = getFile(result.files, 'data/trace/function/attack.mcfunction')
+    expect(fn).toContain('# Generated from: src/main.mcrs:2 (fn attack)')
+    expect(fn).toContain('# Source: fn attack(target: string) -> void')
+  })
+
+  test('mcfunction files include src comments before semantic blocks', () => {
+    const result = compileWithSource(`
+fn attack(target: string): void {
+  say("one");
+  say(target);
+}
+`)
+
+    const fn = getFile(result.files, 'data/trace/function/attack.mcfunction')
+    expect(fn).toContain('# src: src/main.mcrs:3')
+    expect(fn).toContain('# src: src/main.mcrs:4')
+  })
+
+  test('namespace sourcemap maps function names back to source names', () => {
+    const result = compileWithSource(`
+fn attack(target: string): void {
+  say(target);
+}
+`)
+
+    const map = JSON.parse(getFile(result.files, 'trace.sourcemap.json')) as NamespaceSourceMap
+    expect(map.mappings['trace:attack']).toMatchObject({
+      source: 0,
+      line: 2,
+      name: 'attack',
+    })
+  })
+
+  test('supports multi-file namespace sourcemaps', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-sm-'))
+    const srcDir = path.join(tempDir, 'src')
+    fs.mkdirSync(srcDir, { recursive: true })
+    const helperPath = path.join(srcDir, 'helper.mcrs')
+    const mainPath = path.join(srcDir, 'main.mcrs')
+
+    fs.writeFileSync(helperPath, `
+fn support(): void {
+  say("helper");
+}
+`)
+    fs.writeFileSync(mainPath, `
+import helper;
+
+fn attack(): void {
+  support();
+}
+`)
+
+    const result = compile(fs.readFileSync(mainPath, 'utf-8'), {
+      namespace: 'trace',
+      filePath: mainPath,
+      generateSourceMap: true,
+    })
+
+    const map = JSON.parse(getFile(result.files, 'trace.sourcemap.json')) as NamespaceSourceMap
+    expect(map.sources).toEqual([mainPath, helperPath])
+    expect(map.mappings['trace:attack']).toMatchObject({ source: 0, line: 4, name: 'attack' })
+    expect(map.mappings['trace:support']).toMatchObject({ source: 1, line: 2, name: 'support' })
+  })
+
+  test('keeps per-file sourcemap sidecars', () => {
+    const result = compileWithSource(`
+fn attack(target: string): void {
+  say(target);
+}
+`)
+
+    const map = JSON.parse(getFile(result.files, 'data/trace/function/attack.sourcemap.json')) as SourceMap
+    expect(map.generatedFile).toBe('data/trace/function/attack.mcfunction')
+    expect(map.mappings.length).toBeGreaterThan(0)
+  })
+
+  test('execute-run helper call sites keep source comments for runtime tracebacks', () => {
+    const result = compileWithSource(`
+fn attack(): void {
+  execute as @a run {
+    say("hit");
+  }
+}
+`)
+
+    const main = getFile(result.files, 'data/trace/function/attack.mcfunction')
+    const helperPath = result.files.find(file => file.path.includes('__exec_') && file.path.endsWith('.mcfunction'))?.path
+    expect(main).toContain('# src: src/main.mcrs:3')
+    expect(main).toContain('run function trace:')
+    expect(helperPath).toBeDefined()
+    const helper = getFile(result.files, helperPath!)
+    expect(helper).toContain('# Generated from: src/main.mcrs:3')
+  })
+
+  test('namespace sourcemap records nested helper functions', () => {
+    const result = compileWithSource(`
+fn attack(flag: bool): void {
+  if (flag) {
+    say("hit");
+  }
+}
+`)
+
+    const map = JSON.parse(getFile(result.files, 'trace.sourcemap.json')) as NamespaceSourceMap
+    const helperKey = Object.keys(map.mappings).find(key => key.includes('__then_'))
+    expect(helperKey).toBeDefined()
+    expect(map.mappings[helperKey!]).toMatchObject({ source: 0, line: 2, name: expect.any(String) })
+  })
+})

package/src/__tests__/enum.test.ts

@@ -125,13 +125,18 @@ describe('enum: parser', () => {
     expect(matchStmt.kind).toBe('match')
     if (matchStmt.kind === 'match') {
       expect(matchStmt.arms).toHaveLength(2)
+      // Enum variant patterns now parse as PatEnum (previously PatExpr wrapping path_expr)
       expect(matchStmt.arms[0].pattern).toMatchObject({
-        kind: 'PatExpr',
-        expr: { kind: 'path_expr', enumName: 'Phase', variant: 'Idle' },
+        kind: 'PatEnum',
+        enumName: 'Phase',
+        variant: 'Idle',
+        bindings: [],
       })
       expect(matchStmt.arms[1].pattern).toMatchObject({
-        kind: 'PatExpr',
-        expr: { kind: 'path_expr', enumName: 'Phase', variant: 'Moving' },
+        kind: 'PatEnum',
+        enumName: 'Phase',
+        variant: 'Moving',
+        bindings: [],
       })
     }
   })

package/src/__tests__/error-recovery.test.ts

@@ -0,0 +1,226 @@
+/**
+ * Error Recovery Tests
+ *
+ * Verifies that the parser continues after encountering syntax errors,
+ * collecting all diagnostics rather than stopping at the first one.
+ */
+
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { DiagnosticError } from '../diagnostics'
+
+function parseWithErrors(source: string, namespace = 'test'): {
+  errors: DiagnosticError[]
+  parsedFns: string[]
+} {
+  const tokens = new Lexer(source).tokenize()
+  const parser = new Parser(tokens, source)
+  let parsedFns: string[] = []
+  try {
+    const ast = parser.parse(namespace)
+    parsedFns = ast.declarations.map(fn => fn.name)
+  } catch (_) {
+    // Partial AST not returned on throw, but we can inspect parseErrors below
+  }
+  return {
+    errors: parser.parseErrors,
+    parsedFns,
+  }
+}
+
+describe('Parser Error Recovery', () => {
+  describe('top-level declaration recovery', () => {
+    it('reports all errors from multiple broken functions', () => {
+      const source = `
+fn good1() {
+  let x: int = 42;
+}
+
+fn bad1( {
+  let y: int = 1;
+}
+
+fn good2() {
+  let z: int = 99;
+}
+
+fn bad2() {
+  let w: int = ;
+}
+
+fn good3() {}
+`
+      const { errors } = parseWithErrors(source)
+      // Should have collected at least 2 errors (bad1 and bad2)
+      expect(errors.length).toBeGreaterThanOrEqual(2)
+    })
+
+    it('collects errors with correct line numbers', () => {
+      const source = `fn a() {}
+fn b( {
+  let x = 1;
+}
+fn c() {
+  let y = ;
+}
+fn d() {}`
+
+      const { errors } = parseWithErrors(source)
+      expect(errors.length).toBeGreaterThanOrEqual(2)
+      // Each error should have a valid location
+      for (const err of errors) {
+        expect(err.location.line).toBeGreaterThan(0)
+        expect(err.location.col).toBeGreaterThan(0)
+      }
+    })
+
+    it('errors are DiagnosticError instances with ParseError kind', () => {
+      const source = `
+fn broken( {
+  return 1;
+}
+fn also_broken() {
+  let x = ;
+}
+`
+      const { errors } = parseWithErrors(source)
+      expect(errors.length).toBeGreaterThanOrEqual(1)
+      for (const err of errors) {
+        expect(err).toBeInstanceOf(DiagnosticError)
+        expect(err.kind).toBe('ParseError')
+      }
+    })
+
+    it('recovers and continues parsing after struct error', () => {
+      const source = `
+struct Bad {
+  name
+}
+
+struct Good {
+  x: int
+  y: int
+}
+`
+      const { errors } = parseWithErrors(source)
+      expect(errors.length).toBeGreaterThanOrEqual(1)
+    })
+
+    it('recovers from a broken top-level const and still parses later functions', () => {
+      const source = `
+const BAD: = 1;
+
+fn good_after_error() {
+  return;
+}
+`
+      const { errors, parsedFns } = parseWithErrors(source)
+      expect(errors.length).toBeGreaterThanOrEqual(1)
+      expect(parsedFns).toContain('good_after_error')
+    })
+  })
+
+  describe('block-level (statement) recovery', () => {
+    it('collects multiple errors within a single function body', () => {
+      const source = `
+fn multi_error_fn() {
+  let x: int = ;
+  let y: int = 42;
+  let z: int = ;
+  let w: int = 100;
+}
+`
+      const { errors } = parseWithErrors(source)
+      // Should have at least 2 statement-level errors
+      expect(errors.length).toBeGreaterThanOrEqual(2)
+    })
+
+    it('continues parsing after a bad statement', () => {
+      // The second let statement should be parseable even after the first is broken
+      const source = `
+fn test_fn() {
+  let x: int = ;
+  let y: int = 42;
+}
+`
+      const { errors } = parseWithErrors(source)
+      expect(errors.length).toBeGreaterThanOrEqual(1)
+    })
+
+    it('recovers after consuming a bad statement semicolon and keeps later statements', () => {
+      const source = `
+fn test_fn() {
+  let x: int = ;
+  let y: int = 42;
+  return;
+}
+`
+      const tokens = new Lexer(source).tokenize()
+      const parser = new Parser(tokens, source)
+      const ast = parser.parse('test')
+
+      expect(parser.parseErrors.length).toBeGreaterThanOrEqual(1)
+      expect(ast.declarations[0].body.some(stmt => stmt.kind === 'return')).toBe(true)
+    })
+
+    it('recovers at block end without consuming the closing brace', () => {
+      const source = `
+fn broken() {
+  let x: int = }
+
+fn after_broken() {
+  return;
+}
+`
+      const { errors, parsedFns } = parseWithErrors(source)
+      expect(errors.length).toBeGreaterThanOrEqual(1)
+      expect(parsedFns).toContain('broken')
+      expect(parsedFns).toContain('after_broken')
+    })
+  })
+
+  describe('error message quality', () => {
+    it('formats errors with source pointer', () => {
+      const source = `fn foo( {\n  return 1;\n}`
+      const tokens = new Lexer(source).tokenize()
+      const parser = new Parser(tokens, source)
+      try { parser.parse('test') } catch (_) {}
+
+      expect(parser.parseErrors.length).toBeGreaterThanOrEqual(1)
+      const formatted = parser.parseErrors[0].format()
+      expect(formatted).toContain('[ParseError]')
+      expect(formatted).toContain('^')
+      expect(formatted).toContain('line')
+    })
+
+    it('error location points to the problematic token', () => {
+      const source = 'fn f() {\n  let x = ;\n}'
+      const tokens = new Lexer(source).tokenize()
+      const parser = new Parser(tokens, source)
+      try { parser.parse('test') } catch (_) {}
+
+      expect(parser.parseErrors.length).toBeGreaterThanOrEqual(1)
+      const err = parser.parseErrors[0]
+      // The error should be on line 2 (the `let x = ;` line)
+      expect(err.location.line).toBe(2)
+    })
+  })
+
+  describe('parseErrors array is populated', () => {
+    it('is empty for valid programs', () => {
+      const source = 'fn foo() { let x: int = 42; }'
+      const tokens = new Lexer(source).tokenize()
+      const parser = new Parser(tokens, source)
+      parser.parse('test')
+      expect(parser.parseErrors).toHaveLength(0)
+    })
+
+    it('is populated when errors occur', () => {
+      const source = 'fn foo( {'
+      const tokens = new Lexer(source).tokenize()
+      const parser = new Parser(tokens, source)
+      try { parser.parse('test') } catch (_) {}
+      expect(parser.parseErrors.length).toBeGreaterThan(0)
+    })
+  })
+})