redscript-mc 2.0.0 → 2.1.0

package/dist/src/ast/types.d.ts

@@ -36,6 +36,12 @@ export type TypeNode = {
 } | {
     kind: 'selector';
     entityType?: string;
+} | {
+    kind: 'tuple';
+    elements: TypeNode[];
+} | {
+    kind: 'option';
+    inner: TypeNode;
 };
 export interface LambdaParam {
     name: string;
@@ -191,6 +197,7 @@ export type Expr = {
     kind: 'call';
     fn: string;
     args: Expr[];
+    typeArgs?: TypeNode[];
     span?: Span;
 } | {
     kind: 'invoke';
@@ -231,9 +238,25 @@ export type Expr = {
     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;
+} | {
+    kind: 'none_lit';
+    span?: Span;
+};
 export type LiteralExpr = Extract<Expr, {
     kind: 'int_lit';
 }> | Extract<Expr, {
@@ -345,6 +368,12 @@ export type Stmt = {
     type?: TypeNode;
     init: Expr;
     span?: Span;
+} | {
+    kind: 'let_destruct';
+    names: string[];
+    type?: TypeNode;
+    init: Expr;
+    span?: Span;
 } | {
     kind: 'expr';
     expr: Expr;
@@ -399,6 +428,13 @@ export type Stmt = {
         body: Block;
     }[];
     span?: Span;
+} | {
+    kind: 'if_let_some';
+    binding: string;
+    init: Expr;
+    then: Block;
+    else_?: Block;
+    span?: Span;
 } | {
     kind: 'as_block';
     selector: EntitySelector;
@@ -427,7 +463,7 @@ export type Stmt = {
 };
 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;
@@ -435,6 +471,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<{
@@ -455,7 +494,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[];
@@ -500,14 +543,25 @@ export interface GlobalDecl {
     mutable: boolean;
     span?: Span;
 }
+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;
+    span?: Span;
+}
 export interface Program {
     namespace: string;
+    /** 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/dist/src/cache/deps.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ */
+/**
+ * Parse import statements from a source file's content.
+ * Returns absolute paths of imported files.
+ */
+export declare function parseImports(filePath: string, source?: string): string[];
+export declare class DependencyGraph {
+    /** Forward edges: file → set of files it imports */
+    private deps;
+    /** Add a file and its direct imports to the graph. */
+    addFile(filePath: string, source?: string): void;
+    /** Remove a file from the graph. */
+    removeFile(filePath: string): void;
+    /** Get direct imports of a file. */
+    getDirectDeps(filePath: string): Set<string>;
+    /**
+     * Get transitive dependencies of a file (all files it depends on,
+     * directly or indirectly).
+     */
+    getTransitiveDeps(filePath: string): Set<string>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /** Get all tracked files. */
+    getAllFiles(): string[];
+    /** Clear the graph. */
+    clear(): void;
+}

package/dist/src/cache/deps.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyGraph = void 0;
+exports.parseImports = parseImports;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/;
+/**
+ * Parse import statements from a source file's content.
+ * Returns absolute paths of imported files.
+ */
+function parseImports(filePath, source) {
+    const absPath = path.resolve(filePath);
+    const content = source ?? fs.readFileSync(absPath, 'utf-8');
+    const dir = path.dirname(absPath);
+    const imports = [];
+    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;
+}
+class DependencyGraph {
+    constructor() {
+        /** Forward edges: file → set of files it imports */
+        this.deps = new Map();
+    }
+    /** Add a file and its direct imports to the graph. */
+    addFile(filePath, source) {
+        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) {
+        this.deps.delete(path.resolve(filePath));
+    }
+    /** Get direct imports of a file. */
+    getDirectDeps(filePath) {
+        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) {
+        const absPath = path.resolve(filePath);
+        const result = new Set();
+        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) {
+        const absPath = path.resolve(filePath);
+        const result = new Set();
+        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) {
+        const dirty = new Set();
+        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() {
+        return [...this.deps.keys()];
+    }
+    /** Clear the graph. */
+    clear() {
+        this.deps.clear();
+    }
+}
+exports.DependencyGraph = DependencyGraph;
+//# sourceMappingURL=deps.js.map

package/dist/src/cache/incremental.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Incremental compilation — only recompile files whose content (or
+ * dependencies) has changed since the last build.
+ */
+import { type CompileResult } from '../emit/compile';
+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>;
+}
+/**
+ * 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 declare function compileIncremental(files: string[], cache: FileCache, depGraph: DependencyGraph, options: IncrementalOptions): IncrementalResult;
+/**
+ * Reset the in-memory compile cache. Useful for testing.
+ */
+export declare function resetCompileCache(): void;

package/dist/src/cache/incremental.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Incremental compilation — only recompile files whose content (or
+ * dependencies) has changed since the last build.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileIncremental = compileIncremental;
+exports.resetCompileCache = resetCompileCache;
+const path = __importStar(require("path"));
+const compile_1 = require("../emit/compile");
+const fs = __importStar(require("fs"));
+const compiledCache = new Map();
+/**
+ * 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
+ */
+function compileIncremental(files, cache, depGraph, options) {
+    const result = {
+        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();
+    const allSourceFiles = new Set();
+    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 = (0, compile_1.compile)(source, { namespace: ns, filePath: absFile });
+            // Update caches
+            const depHashes = new Map();
+            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.message);
+        }
+    }
+    return result;
+}
+/** Write compile output files to the output directory. */
+function writeBuildOutput(compileResult, output) {
+    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) {
+    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.
+ */
+function resetCompileCache() {
+    compiledCache.clear();
+}
+//# sourceMappingURL=incremental.js.map

package/dist/src/cache/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 type { HIRModule } from '../hir/types';
+export interface CacheEntry {
+    hash: string;
+    mtime: number;
+    hir?: HIRModule;
+}
+export declare class FileCache {
+    private entries;
+    private cacheDir;
+    constructor(cacheDir: string);
+    /** Get cached entry for a file (by absolute path). */
+    get(filePath: string): CacheEntry | undefined;
+    /** Set cache entry for a file. */
+    set(filePath: string, entry: CacheEntry): void;
+    /** Check if a file's content has changed since last cache. */
+    hasChanged(filePath: string): boolean;
+    /** Update the cache entry for a file from disk. Returns true if content changed. */
+    update(filePath: string, hir?: HIRModule): boolean;
+    /** Remove a file from the cache. */
+    delete(filePath: string): void;
+    /** Clear all cache entries. */
+    clear(): void;
+    /** Number of cached entries. */
+    get size(): number;
+    /** Persist cache to disk (`.redscript-cache/cache.json`). */
+    save(): void;
+    /** Load cache from disk. */
+    load(): void;
+}
+/** SHA-256 hash of a file's content. */
+export declare function hashFile(filePath: string): string;