redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/compiler/module-import.test.ts

@@ -0,0 +1,240 @@
+/**
+ * Module import system tests
+ *
+ * Tests for `import <name>` whole-module file imports, where:
+ * - player_utils.mcrs declares `module player_utils`
+ * - main.mcrs uses `import player_utils` (no `::` — imports the whole module by file)
+ *
+ * Unlike the Phase 5b `compileModules` API which handles multi-module datapack
+ * compilation, these tests verify that the `compile()` function can resolve
+ * and merge whole-module imports at the file level.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import { compile } from '../../emit/compile'
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parse(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens, source).parse()
+}
+
+/** Create a temporary directory with given files, return its path. */
+function makeTmpDir(files: Record<string, string>): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-module-'))
+  for (const [name, content] of Object.entries(files)) {
+    fs.writeFileSync(path.join(dir, name), content, 'utf-8')
+  }
+  return dir
+}
+
+function cleanupDir(dir: string): void {
+  fs.rmSync(dir, { recursive: true, force: true })
+}
+
+// ---------------------------------------------------------------------------
+// Parser: `import <name>` (whole-module) is parsed correctly
+// ---------------------------------------------------------------------------
+
+describe('parser: import <name> (whole-module)', () => {
+  test('parses `import player_utils;` as whole-module import (no symbol)', () => {
+    const ast = parse(`
+      import player_utils;
+      fn main() { }
+    `)
+    expect(ast.imports).toHaveLength(1)
+    const imp = ast.imports[0]
+    expect(imp.moduleName).toBe('player_utils')
+    expect(imp.symbol).toBeUndefined()
+  })
+
+  test('parses `import player_utils` without semicolon', () => {
+    const ast = parse(`
+      import player_utils
+      fn main() { }
+    `)
+    expect(ast.imports).toHaveLength(1)
+    expect(ast.imports[0].symbol).toBeUndefined()
+  })
+
+  test('parses `import math::sin;` as symbol import (existing behaviour preserved)', () => {
+    const ast = parse(`
+      module main;
+      import math::sin;
+    `)
+    const imp = ast.imports[0]
+    expect(imp.moduleName).toBe('math')
+    expect(imp.symbol).toBe('sin')
+  })
+
+  test('parses `import math::*;` as wildcard symbol import (existing behaviour preserved)', () => {
+    const ast = parse(`
+      import math::*;
+    `)
+    const imp = ast.imports[0]
+    expect(imp.symbol).toBe('*')
+  })
+
+  test('multiple whole-module imports', () => {
+    const ast = parse(`
+      import player_utils;
+      import math_utils;
+      fn main() { }
+    `)
+    expect(ast.imports).toHaveLength(2)
+    expect(ast.imports[0].moduleName).toBe('player_utils')
+    expect(ast.imports[1].moduleName).toBe('math_utils')
+    for (const imp of ast.imports) {
+      expect(imp.symbol).toBeUndefined()
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Compiler: whole-module import resolution (file-based)
+// ---------------------------------------------------------------------------
+
+describe('compiler: whole-module import resolution', () => {
+  test('resolves and merges a whole-module import from a relative file', () => {
+    const dir = makeTmpDir({
+      'player_utils.mcrs': `
+module player_utils;
+fn get_health_pct(name: string): int {
+  return 75;
+}
+`,
+      'main.mcrs': `
+import player_utils;
+fn on_tick() {
+  let pct: int = get_health_pct("Steve");
+}
+`,
+    })
+
+    try {
+      const source = fs.readFileSync(path.join(dir, 'main.mcrs'), 'utf-8')
+      const result = compile(source, {
+        namespace: 'test',
+        filePath: path.join(dir, 'main.mcrs'),
+      })
+      expect(result.success).toBe(true)
+      const files = result.files.filter(f => f.path.endsWith('.mcfunction'))
+      // get_health_pct should be emitted (reachable from on_tick)
+      const allContent = files.map(f => f.content).join('\n')
+      expect(allContent.length).toBeGreaterThan(0)
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test('throws a diagnostic error when module file is not found', () => {
+    expect(() => {
+      compile(`
+        import nonexistent_module;
+        fn main() { }
+      `, { namespace: 'test', filePath: '/tmp/fake/main.mcrs' })
+    }).toThrow(/Module 'nonexistent_module' not found/)
+  })
+
+  test('whole-module import allows calling imported functions', () => {
+    const dir = makeTmpDir({
+      'utils.mcrs': `
+module utils;
+fn add(a: int, b: int): int {
+  return a + b;
+}
+`,
+      'main.mcrs': `
+import utils;
+fn compute(): int {
+  return add(10, 20);
+}
+`,
+    })
+
+    try {
+      const source = fs.readFileSync(path.join(dir, 'main.mcrs'), 'utf-8')
+      const result = compile(source, {
+        namespace: 'ns',
+        filePath: path.join(dir, 'main.mcrs'),
+      })
+      expect(result.success).toBe(true)
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test('imported module functions are DCE-eligible (not exported as entry points)', () => {
+    const dir = makeTmpDir({
+      'helper.mcrs': `
+module helper;
+fn internal_fn(): int {
+  return 42;
+}
+`,
+      'main.mcrs': `
+import helper;
+fn main_run() {
+  let x: int = internal_fn();
+}
+`,
+    })
+
+    try {
+      const source = fs.readFileSync(path.join(dir, 'main.mcrs'), 'utf-8')
+      const result = compile(source, {
+        namespace: 'test',
+        filePath: path.join(dir, 'main.mcrs'),
+      })
+      expect(result.success).toBe(true)
+      // internal_fn should NOT appear in tick.json or load.json as an entry point
+      const tickTag = result.files.find(f => f.path.includes('tick.json'))
+      const loadTag = result.files.find(f => f.path.includes('load.json'))
+      if (tickTag) expect(tickTag.content).not.toContain('internal_fn')
+      if (loadTag) expect(loadTag.content).not.toContain('internal_fn')
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test('does not import the same module twice (deduplication)', () => {
+    const dir = makeTmpDir({
+      'shared.mcrs': `
+module shared;
+fn shared_fn(): int { return 1; }
+`,
+      'a.mcrs': `
+module a;
+import shared;
+fn use_shared(): int { return shared_fn(); }
+`,
+      'main.mcrs': `
+import a;
+import shared;
+fn main() {
+  let x: int = use_shared();
+  let y: int = shared_fn();
+}
+`,
+    })
+
+    try {
+      const source = fs.readFileSync(path.join(dir, 'main.mcrs'), 'utf-8')
+      // Should not throw a duplicate function error
+      const result = compile(source, {
+        namespace: 'test',
+        filePath: path.join(dir, 'main.mcrs'),
+      })
+      expect(result.success).toBe(true)
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+})

package/src/__tests__/compiler/option-extensions.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Tests for Option extensions:
+ * - while let Some(x) = opt { ... }
+ * - opt.unwrap_or(default)
+ */
+
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { compile } from '../../emit/compile'
+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 {
+  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: while let
+// ---------------------------------------------------------------------------
+
+describe('while let: Parser', () => {
+  it('parses while let Some(x) = opt { ... }', () => {
+    const prog = parse(`
+      fn f(p: Option<int>): void {
+        while let Some(x) = p {
+          let y: int = x;
+        }
+      }
+    `)
+    const stmt = prog.declarations[0].body[0]
+    expect(stmt.kind).toBe('while_let_some')
+    if (stmt.kind === 'while_let_some') {
+      expect(stmt.binding).toBe('x')
+      expect(stmt.init).toEqual({ kind: 'ident', name: 'p' })
+      expect(stmt.body.length).toBe(1)
+    }
+  })
+
+  it('parses while let Some(val) = expr { body }', () => {
+    const prog = parse(`
+      fn f(): void {
+        let opt: Option<int> = Some(5);
+        while let Some(n) = opt {
+          let z: int = n;
+        }
+      }
+    `)
+    const whileStmt = prog.declarations[0].body[1]
+    expect(whileStmt.kind).toBe('while_let_some')
+    if (whileStmt.kind === 'while_let_some') {
+      expect(whileStmt.binding).toBe('n')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Parser: unwrap_or
+// ---------------------------------------------------------------------------
+
+describe('unwrap_or: Parser', () => {
+  it('parses opt.unwrap_or(0)', () => {
+    const prog = parse(`
+      fn f(p: Option<int>): void {
+        let x: int = p.unwrap_or(0);
+      }
+    `)
+    const letStmt = prog.declarations[0].body[0]
+    expect(letStmt.kind).toBe('let')
+    if (letStmt.kind === 'let') {
+      expect(letStmt.init.kind).toBe('unwrap_or')
+      if (letStmt.init.kind === 'unwrap_or') {
+        expect(letStmt.init.opt).toEqual({ kind: 'ident', name: 'p' })
+        expect(letStmt.init.default_).toEqual({ kind: 'int_lit', value: 0 })
+      }
+    }
+  })
+
+  it('parses chained: fn_call().unwrap_or(42)', () => {
+    const prog = parse(`
+      fn make(): Option<int> { return None; }
+      fn f(): void {
+        let val: int = make().unwrap_or(42);
+      }
+    `)
+    const letStmt = prog.declarations[1].body[0]
+    expect(letStmt.kind).toBe('let')
+    if (letStmt.kind === 'let') {
+      expect(letStmt.init.kind).toBe('unwrap_or')
+      if (letStmt.init.kind === 'unwrap_or') {
+        expect(letStmt.init.default_).toEqual({ kind: 'int_lit', value: 42 })
+      }
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// E2E: unwrap_or compilation
+// ---------------------------------------------------------------------------
+
+describe('unwrap_or: E2E', () => {
+  it('compiles Some(5).unwrap_or(0) — result should be 5', () => {
+    const source = `
+      fn test(): void {
+        let p: Option<int> = Some(5);
+        let val: int = p.unwrap_or(0);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+    const fn = getFile(result.files, 'test')
+    expect(fn).toBeDefined()
+    // Should contain scoreboard operations
+    expect(fn).toContain('scoreboard')
+  })
+
+  it('compiles None.unwrap_or(99) — compiles without error', () => {
+    // When opt is None, unwrap_or branches to the merge block with the default value
+    // The default 99 may be DCE'd if val is unused; we just verify compilation succeeds
+    const source = `
+      fn test(): void {
+        let p: Option<int> = None;
+        let val: int = p.unwrap_or(99);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+    const fn = getFile(result.files, 'test')
+    expect(fn).toBeDefined()
+    // has=0 should appear for None
+    expect(fn).toContain('0')
+  })
+
+  it('compiles function-returning Option with unwrap_or', () => {
+    const source = `
+      fn maybe(): Option<int> {
+        return Some(7);
+      }
+      fn test(): void {
+        let val: int = maybe().unwrap_or(0);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// E2E: while let compilation
+// ---------------------------------------------------------------------------
+
+describe('while let: E2E', () => {
+  it('compiles while let Some(x) = opt with known-Some value', () => {
+    const source = `
+      fn test(): void {
+        let opt: Option<int> = Some(1);
+        while let Some(x) = opt {
+          let y: int = x;
+          opt = None;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+    // Should generate a conditional/branch structure
+    const hasConditional = result.files.some(f =>
+      f.content.includes('execute if score') || f.content.includes('scoreboard')
+    )
+    expect(hasConditional).toBe(true)
+  })
+
+  it('compiles while let Some(x) = opt with None — loop body never runs', () => {
+    const source = `
+      fn test(): void {
+        let opt: Option<int> = None;
+        while let Some(x) = opt {
+          let y: int = x;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+  })
+
+  it('compiles while let with function-returning Option', () => {
+    const source = `
+      fn next(): Option<int> {
+        return None;
+      }
+      fn test(): void {
+        let opt: Option<int> = next();
+        while let Some(x) = opt {
+          let y: int = x;
+          opt = next();
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+  })
+})

package/src/__tests__/compiler/profile-decorator.test.ts

@@ -0,0 +1,79 @@
+import { compile } from '../../emit/compile'
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { TypeChecker } from '../../typechecker'
+import type { DiagnosticError } from '../../diagnostics'
+
+function getFile(files: Array<{ path: string; content: string }>, path: string): string {
+  const file = files.find(entry => entry.path === path)
+  if (!file) {
+    throw new Error(`Missing file: ${path}\nFiles:\n${files.map(entry => entry.path).join('\n')}`)
+  }
+  return file.content
+}
+
+function parseDecorators(source: string): string[] {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return ast.declarations[0]?.decorators.map(decorator => decorator.name) ?? []
+}
+
+function typeCheck(source: string): DiagnosticError[] {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return new TypeChecker(source).check(ast)
+}
+
+describe('@profile decorator', () => {
+  test('parser records @profile on the function', () => {
+    expect(parseDecorators(`
+      @profile
+      fn expensive_calculation() {}
+    `)).toContain('profile')
+  })
+
+  test('typechecker rejects duplicate @profile decorators', () => {
+    const errors = typeCheck(`
+      @profile
+      @profile
+      fn expensive_calculation() {}
+    `)
+
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('multiple @profile decorators')
+  })
+
+  test('emits profiler instrumentation and helper functions only in debug mode', () => {
+    const source = `
+      @profile
+      fn expensive_calculation() {
+        let value: int = 42;
+        say("done");
+      }
+    `
+
+    const debugResult = compile(source, { namespace: 'profile_test', debug: true })
+    const regularResult = compile(source, { namespace: 'profile_test' })
+
+    const main = getFile(debugResult.files, 'data/profile_test/function/expensive_calculation.mcfunction')
+    const load = getFile(debugResult.files, 'data/profile_test/function/load.mcfunction')
+    const reset = getFile(debugResult.files, 'data/profile_test/function/__profiler_reset.mcfunction')
+    const report = getFile(debugResult.files, 'data/profile_test/function/__profiler_report.mcfunction')
+
+    expect(main).toContain('# __profiler_start_expensive_calculation')
+    expect(main).toContain('execute store result score #prof_start_expensive_calculation __time run time query gametime')
+    expect(main).toContain('# __profiler_end_expensive_calculation')
+    expect(main).toContain('scoreboard players operation #prof_total_expensive_calculation __profile += #prof_delta_expensive_calculation __time')
+    expect(main).toContain('scoreboard players add #prof_count_expensive_calculation __profile 1')
+
+    expect(load).toContain('scoreboard objectives add __time dummy')
+    expect(load).toContain('scoreboard objectives add __profile dummy')
+    expect(reset).toContain('scoreboard players set #prof_total_expensive_calculation __profile 0')
+    expect(reset).toContain('scoreboard players set #prof_count_expensive_calculation __profile 0')
+    expect(report).toContain('"text":"[profile] expensive_calculation: total="')
+    expect(report).toContain('"name":"#prof_total_expensive_calculation"')
+
+    expect(regularResult.files.find(file => file.path === 'data/profile_test/function/__profiler_reset.mcfunction')).toBeUndefined()
+    expect(getFile(regularResult.files, 'data/profile_test/function/expensive_calculation.mcfunction')).not.toContain('__profiler_start_expensive_calculation')
+  })
+})