redscript-mc 2.0.0 → 2.1.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()
+}

package/src/cache/index.ts

@@ -0,0 +1,135 @@
+/**
+ * FileCache — content-hash-based compilation cache for incremental builds.
+ *
+ * Stores per-file content hashes and optional cached HIR modules.
+ * Persists to `.redscript-cache/` as JSON.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as crypto from 'crypto'
+import type { HIRModule } from '../hir/types'
+
+export interface CacheEntry {
+  hash: string
+  mtime: number
+  hir?: HIRModule
+}
+
+interface SerializedCache {
+  version: 1
+  entries: Record<string, { hash: string; mtime: number }>
+}
+
+export class FileCache {
+  private entries = new Map<string, CacheEntry>()
+  private cacheDir: string
+
+  constructor(cacheDir: string) {
+    this.cacheDir = cacheDir
+  }
+
+  /** Get cached entry for a file (by absolute path). */
+  get(filePath: string): CacheEntry | undefined {
+    return this.entries.get(path.resolve(filePath))
+  }
+
+  /** Set cache entry for a file. */
+  set(filePath: string, entry: CacheEntry): void {
+    this.entries.set(path.resolve(filePath), entry)
+  }
+
+  /** Check if a file's content has changed since last cache. */
+  hasChanged(filePath: string): boolean {
+    const absPath = path.resolve(filePath)
+    const cached = this.entries.get(absPath)
+    if (!cached) return true
+
+    // Quick mtime check first
+    try {
+      const stat = fs.statSync(absPath)
+      if (stat.mtimeMs === cached.mtime) return false
+    } catch {
+      return true
+    }
+
+    // mtime changed — compare content hash
+    const currentHash = hashFile(absPath)
+    return currentHash !== cached.hash
+  }
+
+  /** Update the cache entry for a file from disk. Returns true if content changed. */
+  update(filePath: string, hir?: HIRModule): boolean {
+    const absPath = path.resolve(filePath)
+    const changed = this.hasChanged(absPath)
+
+    if (changed) {
+      try {
+        const stat = fs.statSync(absPath)
+        this.entries.set(absPath, {
+          hash: hashFile(absPath),
+          mtime: stat.mtimeMs,
+          hir,
+        })
+      } catch {
+        this.entries.delete(absPath)
+      }
+    } else if (hir) {
+      // Update HIR even if hash didn't change
+      const entry = this.entries.get(absPath)
+      if (entry) entry.hir = hir
+    }
+
+    return changed
+  }
+
+  /** Remove a file from the cache. */
+  delete(filePath: string): void {
+    this.entries.delete(path.resolve(filePath))
+  }
+
+  /** Clear all cache entries. */
+  clear(): void {
+    this.entries.clear()
+  }
+
+  /** Number of cached entries. */
+  get size(): number {
+    return this.entries.size
+  }
+
+  /** Persist cache to disk (`.redscript-cache/cache.json`). */
+  save(): void {
+    fs.mkdirSync(this.cacheDir, { recursive: true })
+    const serialized: SerializedCache = {
+      version: 1,
+      entries: {},
+    }
+    for (const [filePath, entry] of this.entries) {
+      // Don't persist HIR — it contains non-serializable references
+      serialized.entries[filePath] = { hash: entry.hash, mtime: entry.mtime }
+    }
+    const cachePath = path.join(this.cacheDir, 'cache.json')
+    fs.writeFileSync(cachePath, JSON.stringify(serialized, null, 2))
+  }
+
+  /** Load cache from disk. */
+  load(): void {
+    const cachePath = path.join(this.cacheDir, 'cache.json')
+    try {
+      const data = JSON.parse(fs.readFileSync(cachePath, 'utf-8')) as SerializedCache
+      if (data.version !== 1) return
+      for (const [filePath, entry] of Object.entries(data.entries)) {
+        this.entries.set(filePath, { hash: entry.hash, mtime: entry.mtime })
+      }
+    } catch {
+      // No cache or corrupt — start fresh
+    }
+  }
+}
+
+/** SHA-256 hash of a file's content. */
+export function hashFile(filePath: string): string {
+  const content = fs.readFileSync(filePath)
+  return crypto.createHash('sha256').update(content).digest('hex')
+}