redscript-mc 2.0.0 → 2.1.1

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

@@ -53,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
@@ -163,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 }
@@ -171,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' }>
@@ -217,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 }
@@ -227,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 }
@@ -240,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
@@ -248,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 }>
@@ -268,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[]
@@ -325,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()
+  }
+}

package/src/cache/incremental.ts

@@ -0,0 +1,173 @@
+/**
+ * Incremental compilation — only recompile files whose content (or
+ * dependencies) has changed since the last build.
+ */
+
+import * as path from 'path'
+import { compile, type CompileOptions, type CompileResult } from '../emit/compile'
+import * as fs from 'fs'
+import { FileCache } from './index'
+import { DependencyGraph } from './deps'
+
+export interface IncrementalOptions {
+  namespace?: string
+  /** Output directory for compiled files. */
+  output: string
+}
+
+export interface IncrementalResult {
+  /** Number of files that were recompiled. */
+  recompiled: number
+  /** Number of files that used the cache (skipped). */
+  cached: number
+  /** Files that had errors (path → error message). */
+  errors: Map<string, string>
+  /** Per-file compile results (only for recompiled files). */
+  results: Map<string, CompileResult>
+}
+
+/** Cached compilation output per entry file. */
+interface CompileCacheEntry {
+  result: CompileResult
+  /** Content hashes of entry file + all its transitive deps at compile time. */
+  depHashes: Map<string, string>
+}
+
+const compiledCache = new Map<string, CompileCacheEntry>()
+
+/**
+ * Compile a set of entry files incrementally.
+ *
+ * For each file:
+ * - Compute content hash of the file and all its transitive imports
+ * - If all hashes match the previous build → skip (cache hit)
+ * - If any hash changed → recompile from scratch
+ */
+export function compileIncremental(
+  files: string[],
+  cache: FileCache,
+  depGraph: DependencyGraph,
+  options: IncrementalOptions,
+): IncrementalResult {
+  const result: IncrementalResult = {
+    recompiled: 0,
+    cached: 0,
+    errors: new Map(),
+    results: new Map(),
+  }
+
+  // Phase 1: Update dependency graph for all files
+  for (const file of files) {
+    const absFile = path.resolve(file)
+    try {
+      const source = fs.readFileSync(absFile, 'utf-8')
+      depGraph.addFile(absFile, source)
+    } catch {
+      // File might have been deleted
+      depGraph.removeFile(absFile)
+    }
+  }
+
+  // Phase 2: Detect all changed source files BEFORE recompiling anything.
+  // This prevents cache.update() during one file's recompile from hiding
+  // changes needed by another file that shares the same dependency.
+  const changedSourceFiles = new Set<string>()
+  const allSourceFiles = new Set<string>()
+
+  for (const file of files) {
+    const absFile = path.resolve(file)
+    const allDeps = depGraph.getTransitiveDeps(absFile)
+    allSourceFiles.add(absFile)
+    for (const dep of allDeps) allSourceFiles.add(dep)
+  }
+
+  for (const sourceFile of allSourceFiles) {
+    if (cache.hasChanged(sourceFile)) {
+      changedSourceFiles.add(sourceFile)
+    }
+  }
+
+  // Phase 3: For each entry file, check if it or any dep changed → recompile
+  for (const file of files) {
+    const absFile = path.resolve(file)
+
+    // Collect all files in this compilation unit (entry + transitive deps)
+    const allDeps = depGraph.getTransitiveDeps(absFile)
+    const unitFiles = [absFile, ...allDeps]
+
+    // Check if any file in the unit has changed
+    let needsRecompile = false
+    const prevEntry = compiledCache.get(absFile)
+
+    if (!prevEntry) {
+      needsRecompile = true
+    } else {
+      for (const unitFile of unitFiles) {
+        if (changedSourceFiles.has(unitFile)) {
+          needsRecompile = true
+          break
+        }
+      }
+      // Also check if the set of dependencies changed
+      if (!needsRecompile && prevEntry.depHashes.size !== unitFiles.length) {
+        needsRecompile = true
+      }
+    }
+
+    if (!needsRecompile) {
+      // Cache hit — write cached result to output
+      const cached = compiledCache.get(absFile)!
+      writeBuildOutput(cached.result, options.output)
+      result.cached++
+      continue
+    }
+
+    // Cache miss — recompile
+    try {
+      const source = fs.readFileSync(absFile, 'utf-8')
+      const ns = options.namespace ?? deriveNamespace(absFile)
+      const compileResult = compile(source, { namespace: ns, filePath: absFile })
+
+      // Update caches
+      const depHashes = new Map<string, string>()
+      for (const unitFile of unitFiles) {
+        cache.update(unitFile)
+        const entry = cache.get(unitFile)
+        if (entry) depHashes.set(unitFile, entry.hash)
+      }
+
+      compiledCache.set(absFile, { result: compileResult, depHashes })
+      writeBuildOutput(compileResult, options.output)
+
+      result.recompiled++
+      result.results.set(absFile, compileResult)
+    } catch (err) {
+      result.errors.set(absFile, (err as Error).message)
+    }
+  }
+
+  return result
+}
+
+/** Write compile output files to the output directory. */
+function writeBuildOutput(compileResult: CompileResult, output: string): void {
+  fs.mkdirSync(output, { recursive: true })
+  for (const dataFile of compileResult.files) {
+    const filePath = path.join(output, dataFile.path)
+    const dir = path.dirname(filePath)
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(filePath, dataFile.content)
+  }
+}
+
+function deriveNamespace(filePath: string): string {
+  const basename = path.basename(filePath, path.extname(filePath))
+  return basename.toLowerCase().replace(/[^a-z0-9]/g, '_')
+}
+
+/**
+ * Reset the in-memory compile cache. Useful for testing.
+ */
+export function resetCompileCache(): void {
+  compiledCache.clear()
+}