redscript-mc 1.2.30 → 2.1.0

package/src/__tests__/tuple.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Tests for Phase 2b: Multi-return values / Tuple types
+ *
+ * Covers:
+ * - Tuple type parsing: (int, int)
+ * - Tuple literal parsing: (a, b)
+ * - Destructuring let: let (q, r) = ...
+ * - Function return type: fn f(): (int, int)
+ * - Full compilation to scoreboard commands
+ */
+
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { compile } from '../emit/compile'
+import type { Program, Stmt, Expr } from '../ast/types'
+
+function parse(source: string, namespace = 'test'): Program {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens).parse(namespace)
+}
+
+function parseStmt(source: string): Stmt {
+  const program = parse(`fn _test() { ${source} }`)
+  return program.declarations[0].body[0]
+}
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+// ---------------------------------------------------------------------------
+// Parser tests
+// ---------------------------------------------------------------------------
+
+describe('Tuple: Parser', () => {
+  it('parses tuple type (int, int) as return type', () => {
+    const program = parse('fn f(a: int, b: int): (int, int) {}')
+    const fn = program.declarations[0]
+    expect(fn.returnType).toEqual({ kind: 'tuple', elements: [
+      { kind: 'named', name: 'int' },
+      { kind: 'named', name: 'int' },
+    ]})
+  })
+
+  it('parses tuple type with 3 elements', () => {
+    const program = parse('fn f(): (int, bool, int) {}')
+    expect(program.declarations[0].returnType).toEqual({ kind: 'tuple', elements: [
+      { kind: 'named', name: 'int' },
+      { kind: 'named', name: 'bool' },
+      { kind: 'named', name: 'int' },
+    ]})
+  })
+
+  it('parses tuple literal expression (a, b)', () => {
+    const program = parse(`fn _test(a: int, b: int): (int, int) { return (a, b); }`)
+    const ret = program.declarations[0].body[0]
+    expect(ret.kind).toBe('return')
+    if (ret.kind === 'return' && ret.value) {
+      expect(ret.value.kind).toBe('tuple_lit')
+      if (ret.value.kind === 'tuple_lit') {
+        expect(ret.value.elements).toHaveLength(2)
+        expect(ret.value.elements[0]).toMatchObject({ kind: 'ident', name: 'a' })
+        expect(ret.value.elements[1]).toMatchObject({ kind: 'ident', name: 'b' })
+      }
+    }
+  })
+
+  it('parses destructuring let statement', () => {
+    const stmt = parseStmt('let (q, r) = divmod(10, 3);')
+    expect(stmt.kind).toBe('let_destruct')
+    if (stmt.kind === 'let_destruct') {
+      expect(stmt.names).toEqual(['q', 'r'])
+      expect(stmt.init).toMatchObject({ kind: 'call', fn: 'divmod' })
+    }
+  })
+
+  it('parses destructuring with 3 bindings', () => {
+    const stmt = parseStmt('let (a, b, c) = get_triple(1);')
+    expect(stmt.kind).toBe('let_destruct')
+    if (stmt.kind === 'let_destruct') {
+      expect(stmt.names).toEqual(['a', 'b', 'c'])
+    }
+  })
+
+  it('does not confuse (expr) grouped expression with tuple literal', () => {
+    const program = parse(`fn _test(): int { return (1 + 2); }`)
+    const ret = program.declarations[0].body[0]
+    expect(ret.kind).toBe('return')
+    if (ret.kind === 'return' && ret.value) {
+      expect(ret.value.kind).toBe('binary')
+    }
+  })
+
+  it('still parses function type (int) -> int correctly', () => {
+    const program = parse('fn apply(f: (int) -> int, x: int): int {}')
+    const param = program.declarations[0].params[0]
+    expect(param.type).toEqual({ kind: 'function_type', params: [{ kind: 'named', name: 'int' }], return: { kind: 'named', name: 'int' } })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// E2E compilation tests
+// ---------------------------------------------------------------------------
+
+describe('Tuple: E2E compilation', () => {
+  test('basic divmod function compiles and writes $ret_0 and $ret_1', () => {
+    const source = `
+      fn divmod(a: int, b: int): (int, int) {
+        return (a / b, a % b);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'divmod.mcfunction')
+    expect(fn).toBeDefined()
+    // MIR __rf_0 → LIR $ret_0 (see lir/lower.ts slot() method)
+    expect(fn).toContain('$ret_0')
+    expect(fn).toContain('$ret_1')
+  })
+
+  test('destructuring let reads from $ret_ slots after call', () => {
+    const source = `
+      fn divmod(a: int, b: int): (int, int) {
+        return (a / b, a % b);
+      }
+      fn use_divmod(): int {
+        let (q, r) = divmod(10, 3);
+        return q + r;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'use_divmod.mcfunction')
+    expect(fn).toBeDefined()
+    // Should call divmod and then read from $ret_ slots
+    expect(fn).toContain('divmod')
+    expect(fn).toContain('$ret_0')
+    expect(fn).toContain('$ret_1')
+  })
+
+  test('tuple literal assigned directly via destructuring', () => {
+    const source = `
+      fn make_sum(a: int, b: int): int {
+        let (x, y) = (a + 1, b + 2);
+        return x + y;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'make_sum.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('scoreboard players operation')
+  })
+
+  test('tuple values used in subsequent computation', () => {
+    const source = `
+      fn divmod(a: int, b: int): (int, int) {
+        return (a / b, a % b);
+      }
+      fn compute(): int {
+        let (q, r) = divmod(10, 3);
+        return q + r;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'compute.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('scoreboard players operation')
+  })
+
+  test('3-tuple return and destructuring', () => {
+    const source = `
+      fn triple(a: int): (int, int, int) {
+        return (a, a + 1, a + 2);
+      }
+      fn use_triple(): int {
+        let (x, y, z) = triple(5);
+        return x + y + z;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const tripleFn = getFile(result.files, 'triple.mcfunction')
+    expect(tripleFn).toBeDefined()
+    expect(tripleFn).toContain('$ret_0')
+    expect(tripleFn).toContain('$ret_1')
+    expect(tripleFn).toContain('$ret_2')
+  })
+
+  test('enum and tuple combined: return (int, Phase)', () => {
+    const source = `
+      enum Phase { Idle, Running, Done }
+      fn get_state(): (int, int) {
+        return (42, Phase::Running);
+      }
+      fn use_state(): int {
+        let (count, phase) = get_state();
+        return count + phase;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'get_state.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('$ret_0')
+    expect(fn).toContain('$ret_1')
+    // Phase::Running = 1
+    expect(fn).toContain('1')
+  })
+
+  test('tuple return type appears in generated mcfunction with correct objective', () => {
+    const source = `
+      fn minmax(a: int, b: int): (int, int) {
+        return (a, b);
+      }
+    `
+    const result = compile(source, { namespace: 'ns' })
+    const fn = getFile(result.files, 'minmax.mcfunction')
+    expect(fn).toBeDefined()
+    // MIR __rf_0 → LIR $ret_0
+    expect(fn).toContain('$ret_0')
+    expect(fn).toContain('__ns')
+  })
+})

package/src/__tests__/typechecker-strict.test.ts

@@ -0,0 +1,216 @@
+/**
+ * Phase 6b: TypeChecker strict (error-mode) tests
+ *
+ * Covers:
+ * - Type errors now block compilation (error-mode default)
+ * - --lenient flag demotes type errors to warnings
+ * - int/float implicit conversion detection
+ * - redscript check command correctly reports type errors
+ */
+
+import { compile } from '../emit/compile'
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { TypeChecker } from '../typechecker'
+import type { DiagnosticError } from '../diagnostics'
+
+// Helper: run TypeChecker directly
+function typeCheck(source: string): DiagnosticError[] {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  const checker = new TypeChecker(source)
+  return checker.check(ast)
+}
+
+// Helper: compile in strict mode (default)
+function compileStrict(source: string): void {
+  compile(source, { namespace: 'test' })
+}
+
+// Helper: compile in lenient mode
+function compileLenient(source: string): { warnings: string[] } {
+  return compile(source, { namespace: 'test', lenient: true })
+}
+
+describe('TypeChecker error-mode (Phase 6b)', () => {
+  describe('type errors block compilation', () => {
+    it('throws on undeclared variable usage', () => {
+      expect(() => compileStrict(`
+fn test() {
+    let x: int = undeclared;
+}
+`)).toThrow()
+    })
+
+    it('throws on return type mismatch', () => {
+      expect(() => compileStrict(`
+fn get_bool() -> bool {
+    return 5;
+}
+`)).toThrow()
+    })
+
+    it('throws on wrong argument count', () => {
+      expect(() => compileStrict(`
+fn add(a: int, b: int) -> int {
+    return a + b;
+}
+fn test() {
+    let x: int = add(1);
+}
+`)).toThrow()
+    })
+
+    it('does not throw for valid programs', () => {
+      expect(() => compileStrict(`
+fn add(a: int, b: int) -> int {
+    return a + b;
+}
+fn test() {
+    let x: int = add(1, 2);
+}
+`)).not.toThrow()
+    })
+  })
+
+  describe('--lenient mode', () => {
+    it('does not throw on type errors in lenient mode', () => {
+      expect(() => compileLenient(`
+fn test() {
+    let x: int = undeclared;
+}
+`)).not.toThrow()
+    })
+
+    it('returns type errors as warnings in lenient mode', () => {
+      const result = compileLenient(`
+fn test() {
+    let x: int = undeclared;
+}
+`)
+      expect(result.warnings.length).toBeGreaterThan(0)
+      expect(result.warnings[0]).toContain('TypeError')
+    })
+
+    it('emits no warnings for valid programs in lenient mode', () => {
+      const result = compileLenient(`
+fn test() {
+    let x: int = 5;
+}
+`)
+      expect(result.warnings).toHaveLength(0)
+    })
+  })
+
+  describe('int/float implicit conversion checks', () => {
+    it('detects int assigned to float variable', () => {
+      // int literal assigned to float — different types
+      const errors = typeCheck(`
+fn test() {
+    let x: float = 5;
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('cannot implicitly convert int to float')
+      expect(errors[0].message).toContain('as float')
+    })
+
+    it('detects float assigned to int variable', () => {
+      const errors = typeCheck(`
+fn get_f() -> float {
+    return 3.14;
+}
+fn test() {
+    let x: int = get_f();
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('cannot implicitly convert')
+    })
+
+    it('detects int/float return type mismatch', () => {
+      const errors = typeCheck(`
+fn get_float() -> float {
+    return 5;
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('cannot implicitly convert int to float')
+      expect(errors[0].message).toContain('as float')
+    })
+
+    it('detects float/int return type mismatch', () => {
+      const errors = typeCheck(`
+fn get_int() -> int {
+    return 3.14;
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('cannot implicitly convert float to int')
+      expect(errors[0].message).toContain('as int')
+    })
+
+    it('allows int assigned to int variable', () => {
+      const errors = typeCheck(`
+fn test() {
+    let x: int = 5;
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('allows float assigned to float variable', () => {
+      const errors = typeCheck(`
+fn get_f() -> float {
+    return 3.14;
+}
+fn test() {
+    let x: float = get_f();
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('blocks compilation on int→float mismatch', () => {
+      expect(() => compileStrict(`
+fn get_float() -> float {
+    return 5;
+}
+`)).toThrow()
+    })
+
+    it('int→float mismatch demoted to warning in lenient mode', () => {
+      const result = compileLenient(`
+fn get_float() -> float {
+    return 5;
+}
+`)
+      expect(result.warnings.length).toBeGreaterThan(0)
+      expect(result.warnings[0]).toContain('TypeError')
+    })
+  })
+
+  describe('redscript check command behavior', () => {
+    it('TypeChecker check() returns errors for type mismatches', () => {
+      const errors = typeCheck(`
+fn test() {
+    let x: int = undeclared;
+    let y: bool = 1;
+}
+`)
+      expect(errors.length).toBeGreaterThanOrEqual(1)
+    })
+
+    it('TypeChecker check() returns empty array for valid programs', () => {
+      const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+fn test() {
+    let p: Point = { x: 10, y: 20 };
+    let val: int = p.x;
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+  })
+})

package/src/ast/types.ts

@@ -5,7 +5,12 @@
  * The AST is produced by the parser and consumed by the lowering pass.
  */
 
-import type { BinOp, CmpOp } from '../ir/types'
+// ---------------------------------------------------------------------------
+// Binary / comparison operators (shared across AST, HIR, MIR)
+// ---------------------------------------------------------------------------
+
+export type BinOp = '+' | '-' | '*' | '/' | '%'
+export type CmpOp = '==' | '!=' | '<' | '<=' | '>' | '>='
 
 // ---------------------------------------------------------------------------
 // Source Span
@@ -48,6 +53,8 @@ export type TypeNode =
   | { kind: 'function_type'; params: TypeNode[]; return: TypeNode }
   | { kind: 'entity'; entityType: EntityTypeName }  // Entity types
   | { kind: 'selector'; entityType?: string }  // Selector type, optionally parameterized: selector<Player>
+  | { kind: 'tuple'; elements: TypeNode[] }  // Tuple type: (int, int, bool)
+  | { kind: 'option'; inner: TypeNode }  // Option<T> — null safety wrapper
 
 export interface LambdaParam {
   name: string
@@ -158,7 +165,7 @@ export type Expr =
   | { kind: 'is_check';   expr: Expr; entityType: EntityTypeName; span?: Span }
   | { kind: 'unary';      op: '!' | '-'; operand: Expr; span?: Span }
   | { kind: 'assign';     target: string; op: AssignOp; value: Expr; span?: Span }
-  | { kind: 'call';       fn: string; args: Expr[]; span?: Span }
+  | { kind: 'call';       fn: string; args: Expr[]; typeArgs?: TypeNode[]; span?: Span }
   | { kind: 'invoke';     callee: Expr; args: Expr[]; span?: Span }
   | { kind: 'member';     obj: Expr; field: string; span?: Span }
   | { kind: 'struct_lit'; fields: { name: string; value: Expr }[]; span?: Span }
@@ -166,7 +173,11 @@ export type Expr =
   | { kind: 'index';      obj: Expr; index: Expr; span?: Span }
   | { kind: 'array_lit';  elements: Expr[]; span?: Span }
   | { kind: 'static_call'; type: string; method: string; args: Expr[]; span?: Span }
+  | { kind: 'path_expr'; enumName: string; variant: string; span?: Span }
   | (LambdaExpr & { span?: Span })
+  | { kind: 'tuple_lit'; elements: Expr[]; span?: Span }
+  | { kind: 'some_lit'; value: Expr; span?: Span }  // Some(expr)
+  | { kind: 'none_lit'; span?: Span }               // None
 
 export type LiteralExpr =
   | Extract<Expr, { kind: 'int_lit' }>
@@ -212,6 +223,7 @@ export type ExecuteSubcommand =
 
 export type Stmt =
   | { kind: 'let';        name: string; type?: TypeNode; init: Expr; span?: Span }
+  | { kind: 'let_destruct'; names: string[]; type?: TypeNode; init: Expr; span?: Span }
   | { kind: 'expr';       expr: Expr; span?: Span }
   | { kind: 'return';     value?: Expr; span?: Span }
   | { kind: 'break';      span?: Span }
@@ -222,6 +234,7 @@ export type Stmt =
   | { kind: 'foreach';    binding: string; iterable: Expr; body: Block; executeContext?: string; span?: Span }
   | { kind: 'for_range';  varName: string; start: Expr; end: Expr; body: Block; span?: Span }
   | { kind: 'match';      expr: Expr; arms: { pattern: Expr | null; body: Block }[]; span?: Span }
+  | { kind: 'if_let_some'; binding: string; init: Expr; then: Block; else_?: Block; span?: Span }
   | { kind: 'as_block';   selector: EntitySelector; body: Block; span?: Span }
   | { kind: 'at_block';   selector: EntitySelector; body: Block; span?: Span }
   | { kind: 'as_at';      as_sel: EntitySelector; at_sel: EntitySelector; body: Block; span?: Span }
@@ -235,7 +248,7 @@ export type Block = Stmt[]
 // ---------------------------------------------------------------------------
 
 export interface Decorator {
-  name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team' | 'keep' | 'require_on_load'
+  name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team' | 'keep' | 'require_on_load' | 'coroutine' | 'schedule'
   args?: {
     rate?: number
     eventType?: string
@@ -243,6 +256,9 @@ export interface Decorator {
     advancement?: string
     item?: string
     team?: string
+    batch?: number
+    onDone?: string
+    ticks?: number
   }
   /** Raw positional arguments (used by @requires and future generic decorators). */
   rawArgs?: Array<{ kind: 'string'; value: string } | { kind: 'number'; value: number }>
@@ -263,7 +279,11 @@ export interface FnDecl {
    *  Library functions are NOT MC entry points — DCE only keeps them if they
    *  are reachable from a non-library (user) entry point. */
   isLibraryFn?: boolean
+  /** True when declared with `export fn` or `@keep fn` — survives DCE. */
+  isExported?: boolean
   name: string
+  /** Generic type parameter names, e.g. ['T'] for fn foo<T>(...) */
+  typeParams?: string[]
   params: Param[]
   returnType: TypeNode
   decorators: Decorator[]
@@ -320,18 +340,34 @@ export interface GlobalDecl {
   span?: Span
 }
 
+// ---------------------------------------------------------------------------
+// Import Declarations (Phase 5b module system)
+// ---------------------------------------------------------------------------
+
+export interface ImportDecl {
+  /** The module being imported from, e.g. "math" in `import math::sin` */
+  moduleName: string
+  /** The symbol being imported, or '*' for wildcard */
+  symbol: string   // '*' | identifier
+  span?: Span
+}
+
 // ---------------------------------------------------------------------------
 // Program (Top-Level)
 // ---------------------------------------------------------------------------
 
 export interface Program {
   namespace: string    // Inferred from filename or `namespace mypack;`
+  /** Module name declared with `module <name>;` (undefined if no module decl) */
+  moduleName?: string
   globals: GlobalDecl[]
   declarations: FnDecl[]
   structs: StructDecl[]
   implBlocks: ImplBlock[]
   enums: EnumDecl[]
   consts: ConstDecl[]
+  /** Phase 5b: module imports (`import math::sin;`) */
+  imports: ImportDecl[]
   /** True when the source file declares `module library;`.
    *  Library-mode: all functions are DCE-eligible by default — none are treated
    *  as MC entry points unless they carry @tick / @load / @on / @keep etc. */

package/src/cache/deps.ts

@@ -0,0 +1,132 @@
+/**
+ * DependencyGraph — tracks import relationships between .mcrs files.
+ *
+ * Builds a forward dependency map (file → files it imports) and supports
+ * reverse lookups (file → files that depend on it) for change propagation.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+
+const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/
+
+/**
+ * Parse import statements from a source file's content.
+ * Returns absolute paths of imported files.
+ */
+export function parseImports(filePath: string, source?: string): string[] {
+  const absPath = path.resolve(filePath)
+  const content = source ?? fs.readFileSync(absPath, 'utf-8')
+  const dir = path.dirname(absPath)
+  const imports: string[] = []
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    // Stop at first non-comment, non-blank, non-import line
+    if (!trimmed || trimmed.startsWith('//')) continue
+    const match = trimmed.match(IMPORT_RE)
+    if (match) {
+      imports.push(path.resolve(dir, match[1]))
+    } else {
+      // Past the import header
+      break
+    }
+  }
+
+  return imports
+}
+
+export class DependencyGraph {
+  /** Forward edges: file → set of files it imports */
+  private deps = new Map<string, Set<string>>()
+
+  /** Add a file and its direct imports to the graph. */
+  addFile(filePath: string, source?: string): void {
+    const absPath = path.resolve(filePath)
+    const imports = parseImports(absPath, source)
+    this.deps.set(absPath, new Set(imports))
+  }
+
+  /** Remove a file from the graph. */
+  removeFile(filePath: string): void {
+    this.deps.delete(path.resolve(filePath))
+  }
+
+  /** Get direct imports of a file. */
+  getDirectDeps(filePath: string): Set<string> {
+    return this.deps.get(path.resolve(filePath)) ?? new Set()
+  }
+
+  /**
+   * Get transitive dependencies of a file (all files it depends on,
+   * directly or indirectly).
+   */
+  getTransitiveDeps(filePath: string): Set<string> {
+    const absPath = path.resolve(filePath)
+    const result = new Set<string>()
+    const stack = [absPath]
+
+    while (stack.length > 0) {
+      const current = stack.pop()!
+      const directDeps = this.deps.get(current)
+      if (!directDeps) continue
+      for (const dep of directDeps) {
+        if (!result.has(dep)) {
+          result.add(dep)
+          stack.push(dep)
+        }
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Get reverse dependents: all files that (transitively) depend on the
+   * given file. Used for change propagation — when `filePath` changes,
+   * all returned files need recompilation.
+   */
+  getDependents(filePath: string): Set<string> {
+    const absPath = path.resolve(filePath)
+    const result = new Set<string>()
+    const stack = [absPath]
+
+    while (stack.length > 0) {
+      const current = stack.pop()!
+      for (const [file, deps] of this.deps) {
+        if (deps.has(current) && !result.has(file)) {
+          result.add(file)
+          stack.push(file)
+        }
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Given a set of changed files, compute the full set of dirty files
+   * (changed files + all their reverse dependents).
+   */
+  computeDirtySet(changedFiles: Set<string>): Set<string> {
+    const dirty = new Set<string>()
+    for (const file of changedFiles) {
+      const absFile = path.resolve(file)
+      dirty.add(absFile)
+      for (const dep of this.getDependents(absFile)) {
+        dirty.add(dep)
+      }
+    }
+    return dirty
+  }
+
+  /** Get all tracked files. */
+  getAllFiles(): string[] {
+    return [...this.deps.keys()]
+  }
+
+  /** Clear the graph. */
+  clear(): void {
+    this.deps.clear()
+  }
+}