redscript-mc 2.6.2 → 3.0.0

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

@@ -250,6 +250,15 @@ export type Expr = {
     enumName: string;
     variant: string;
     span?: Span;
+} | {
+    kind: 'enum_construct';
+    enumName: string;
+    variant: string;
+    args: {
+        name: string;
+        value: Expr;
+    }[];
+    span?: Span;
 } | (LambdaExpr & {
     span?: Span;
 }) | {
@@ -263,6 +272,11 @@ export type Expr = {
 } | {
     kind: 'none_lit';
     span?: Span;
+} | {
+    kind: 'unwrap_or';
+    opt: Expr;
+    default_: Expr;
+    span?: Span;
 } | {
     kind: 'type_cast';
     expr: Expr;
@@ -387,6 +401,11 @@ export type MatchPattern = {
 } | {
     kind: 'PatExpr';
     expr: Expr;
+} | {
+    kind: 'PatEnum';
+    enumName: string;
+    variant: string;
+    bindings: string[];
 };
 export type Stmt = {
     kind: 'let';
@@ -400,6 +419,12 @@ export type Stmt = {
     type?: TypeNode;
     init: Expr;
     span?: Span;
+} | {
+    kind: 'const_decl';
+    name: string;
+    type: TypeNode;
+    value: Expr;
+    span?: Span;
 } | {
     kind: 'expr';
     expr: Expr;
@@ -414,6 +439,19 @@ export type Stmt = {
 } | {
     kind: 'continue';
     span?: Span;
+} | {
+    kind: 'break_label';
+    label: string;
+    span?: Span;
+} | {
+    kind: 'continue_label';
+    label: string;
+    span?: Span;
+} | {
+    kind: 'labeled_loop';
+    label: string;
+    body: Stmt;
+    span?: Span;
 } | {
     kind: 'if';
     cond: Expr;
@@ -425,6 +463,16 @@ export type Stmt = {
     cond: Expr;
     body: Block;
     span?: Span;
+} | {
+    kind: 'do_while';
+    cond: Expr;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'repeat';
+    count: number;
+    body: Block;
+    span?: Span;
 } | {
     kind: 'for';
     init?: Stmt;
@@ -475,6 +523,12 @@ export type Stmt = {
     then: Block;
     else_?: Block;
     span?: Span;
+} | {
+    kind: 'while_let_some';
+    binding: string;
+    init: Expr;
+    body: Block;
+    span?: Span;
 } | {
     kind: 'as_block';
     selector: EntitySelector;
@@ -503,9 +557,10 @@ 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' | 'coroutine' | 'schedule';
+    name: 'tick' | 'load' | 'watch' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team' | 'keep' | 'require_on_load' | 'coroutine' | 'schedule' | 'deprecated' | 'inline' | 'no-inline' | 'config' | 'singleton' | 'profile' | 'throttle' | 'retry' | 'memoize' | 'test';
     args?: {
         rate?: number;
+        objective?: string;
         eventType?: string;
         trigger?: string;
         advancement?: string;
@@ -514,6 +569,16 @@ export interface Decorator {
         batch?: number;
         onDone?: string;
         ticks?: number;
+        /** @deprecated decorator message */
+        message?: string;
+        /** @config decorator: config key name */
+        configKey?: string;
+        /** @config decorator: default value */
+        configDefault?: number;
+        /** @retry decorator: max retry count */
+        max?: number;
+        /** @test decorator: human-readable test label */
+        testLabel?: string;
     };
     /** Raw positional arguments (used by @requires and future generic decorators). */
     rawArgs?: Array<{
@@ -536,6 +601,8 @@ export interface FnDecl {
     isLibraryFn?: boolean;
     /** True when declared with `export fn` or `@keep fn` — survives DCE. */
     isExported?: boolean;
+    /** Scoreboard objective watched by @watch("..."), if present. */
+    watchObjective?: string;
     name: string;
     /** Generic type parameter names, e.g. ['T'] for fn foo<T>(...) */
     typeParams?: string[];
@@ -544,6 +611,7 @@ export interface FnDecl {
     decorators: Decorator[];
     body: Block;
     span?: Span;
+    sourceFile?: string;
 }
 export interface StructField {
     name: string;
@@ -551,18 +619,42 @@ export interface StructField {
 }
 export interface StructDecl {
     name: string;
+    extends?: string;
     fields: StructField[];
+    /** True when the struct was declared with `@singleton` */
+    isSingleton?: boolean;
     span?: Span;
 }
 export interface ImplBlock {
     kind: 'impl_block';
     typeName: string;
+    /** Trait name when declared as `impl TraitName for TypeName` (e.g. "Display") */
+    traitName?: string;
     methods: FnDecl[];
     span?: Span;
 }
+/** A method signature in an interface body (no body) */
+export interface InterfaceMethod {
+    name: string;
+    params: Param[];
+    returnType?: TypeNode;
+    span?: Span;
+}
+/** `interface Drawable { fn draw(self, x: int, y: int) ... }` */
+export interface InterfaceDecl {
+    name: string;
+    methods: InterfaceMethod[];
+    span?: Span;
+}
+export interface EnumPayloadField {
+    name: string;
+    type: TypeNode;
+}
 export interface EnumVariant {
     name: string;
     value?: number;
+    /** Payload fields for tuple-like variants, e.g. RGB(r: int, g: int, b: int) */
+    fields?: EnumPayloadField[];
 }
 export interface EnumDecl {
     name: string;
@@ -581,13 +673,18 @@ export interface GlobalDecl {
     type: TypeNode;
     init: Expr;
     mutable: boolean;
+    /** Present when the global was declared with @config("key", default: value) */
+    configKey?: string;
+    /** Default value for @config globals */
+    configDefault?: number;
     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;
+    /** The symbol being imported, or '*' for wildcard.
+     *  Undefined when this is a whole-module file import (`import player_utils`). */
+    symbol?: string;
     span?: Span;
 }
 export interface Program {
@@ -602,6 +699,8 @@ export interface Program {
     consts: ConstDecl[];
     /** Phase 5b: module imports (`import math::sin;`) */
     imports: ImportDecl[];
+    /** Interface / trait declarations */
+    interfaces: InterfaceDecl[];
     /** 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/incremental.d.ts

@@ -1,14 +1,18 @@
 /**
- * Incremental compilation — only recompile files whose content (or
- * dependencies) has changed since the last build.
+ * Incremental compilation — only recompile files whose content, imports,
+ * or reverse dependents changed since the last build.
  */
-import { type CompileResult } from '../emit/compile';
+import { type CompileOptions, 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;
+    generateSourceMap?: boolean;
+    mcVersion?: CompileOptions['mcVersion'];
+    lenient?: boolean;
+    includeDirs?: string[];
 }
 export interface IncrementalResult {
     /** Number of files that were recompiled. */
@@ -19,17 +23,12 @@ export interface IncrementalResult {
     errors: Map<string, string>;
     /** Per-file compile results (only for recompiled files). */
     results: Map<string, CompileResult>;
+    /** Files skipped due to cache hit. */
+    skippedFiles: string[];
+    /** Files rebuilt in this run. */
+    rebuiltFiles: string[];
+    /** Elapsed wall time for this run. */
+    elapsedMs: number;
 }
-/**
- * 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

@@ -1,7 +1,7 @@
 "use strict";
 /**
- * Incremental compilation — only recompile files whose content (or
- * dependencies) has changed since the last build.
+ * Incremental compilation — only recompile files whose content, imports,
+ * or reverse dependents changed since the last build.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -39,127 +39,144 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileIncremental = compileIncremental;
 exports.resetCompileCache = resetCompileCache;
+const fs = __importStar(require("fs"));
 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
- */
+const deps_1 = require("./deps");
 function compileIncremental(files, cache, depGraph, options) {
+    const start = Date.now();
+    const normalizedEntries = [...new Set(files.map(file => path.resolve(file)))];
     const result = {
         recompiled: 0,
         cached: 0,
         errors: new Map(),
         results: new Map(),
+        skippedFiles: [],
+        rebuiltFiles: [],
+        elapsedMs: 0,
     };
-    // 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);
-        }
+    if (normalizedEntries.length === 0) {
+        result.elapsedMs = Date.now() - start;
+        return result;
     }
-    // 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);
+    depGraph.clear();
+    const discoveredFiles = discoverDependencyGraph(normalizedEntries, depGraph);
+    const changedFiles = new Set();
+    for (const file of discoveredFiles) {
+        if (cache.hasChanged(file))
+            changedFiles.add(file);
     }
-    for (const sourceFile of allSourceFiles) {
-        if (cache.hasChanged(sourceFile)) {
-            changedSourceFiles.add(sourceFile);
-        }
+    const dirtyFiles = depGraph.computeDirtySet(changedFiles);
+    for (const entry of normalizedEntries) {
+        if (!discoveredFiles.has(entry))
+            dirtyFiles.add(entry);
     }
-    // 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);
+    for (const entryFile of normalizedEntries) {
+        const entryDeps = depGraph.getTransitiveDeps(entryFile);
+        const entryUnit = new Set([entryFile, ...entryDeps]);
+        const cachedEntry = cache.get(entryFile);
+        const cachedDepList = new Set(cachedEntry?.dependencies ?? []);
+        const hasDependencyDrift = cachedDepList.size !== entryUnit.size ||
+            [...entryUnit].some(file => !cachedDepList.has(file));
+        const canUseCache = !dirtyFiles.has(entryFile) &&
+            !hasDependencyDrift &&
+            !!cachedEntry?.outputFiles &&
+            cachedEntry.outputFiles.length > 0;
+        if (canUseCache) {
+            writeBuildOutput(cachedEntry.outputFiles, options.output);
             result.cached++;
+            result.skippedFiles.push(entryFile);
             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);
+            const source = fs.readFileSync(entryFile, 'utf-8');
+            const ns = options.namespace ?? deriveNamespace(entryFile);
+            const compileResult = (0, compile_1.compile)(source, {
+                namespace: ns,
+                filePath: entryFile,
+                generateSourceMap: options.generateSourceMap,
+                mcVersion: options.mcVersion,
+                lenient: options.lenient,
+                includeDirs: options.includeDirs,
+            });
+            const outputFiles = cloneFiles(compileResult.files);
+            const compiledFunctions = outputFiles
+                .filter(file => file.path.endsWith('.mcfunction'))
+                .map(file => file.path);
+            removeStaleOutputs(cachedEntry?.outputFiles ?? [], outputFiles, options.output);
+            for (const file of entryUnit) {
+                cache.update(file);
+            }
+            const entryRecord = cache.get(entryFile);
+            if (entryRecord) {
+                entryRecord.compiledFunctions = compiledFunctions;
+                entryRecord.outputFiles = outputFiles;
+                entryRecord.dependencies = [...entryUnit].sort();
             }
-            compiledCache.set(absFile, { result: compileResult, depHashes });
-            writeBuildOutput(compileResult, options.output);
+            writeBuildOutput(outputFiles, options.output);
             result.recompiled++;
-            result.results.set(absFile, compileResult);
+            result.results.set(entryFile, compileResult);
+            result.rebuiltFiles.push(entryFile);
         }
         catch (err) {
-            result.errors.set(absFile, err.message);
+            result.errors.set(entryFile, err.message);
         }
     }
+    cache.save();
+    result.elapsedMs = Date.now() - start;
     return result;
 }
+function discoverDependencyGraph(entries, depGraph) {
+    const visited = new Set();
+    const queue = [...entries];
+    while (queue.length > 0) {
+        const current = path.resolve(queue.shift());
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        try {
+            const source = fs.readFileSync(current, 'utf-8');
+            depGraph.addFile(current, source);
+            const imports = (0, deps_1.parseImports)(current, source);
+            for (const imported of imports) {
+                if (!visited.has(imported))
+                    queue.push(imported);
+            }
+        }
+        catch {
+            depGraph.removeFile(current);
+        }
+    }
+    return visited;
+}
+function cloneFiles(files) {
+    return files.map(file => ({ path: file.path, content: file.content }));
+}
 /** Write compile output files to the output directory. */
-function writeBuildOutput(compileResult, output) {
+function writeBuildOutput(files, output) {
     fs.mkdirSync(output, { recursive: true });
-    for (const dataFile of compileResult.files) {
+    for (const dataFile of files) {
         const filePath = path.join(output, dataFile.path);
         const dir = path.dirname(filePath);
         fs.mkdirSync(dir, { recursive: true });
         fs.writeFileSync(filePath, dataFile.content);
     }
 }
+function removeStaleOutputs(previousFiles, nextFiles, output) {
+    if (previousFiles.length === 0)
+        return;
+    const nextPaths = new Set(nextFiles.map(file => file.path));
+    for (const oldFile of previousFiles) {
+        if (nextPaths.has(oldFile.path))
+            continue;
+        const targetPath = path.join(output, oldFile.path);
+        if (fs.existsSync(targetPath))
+            fs.rmSync(targetPath, { force: true });
+    }
+}
 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();
-}
+function resetCompileCache() { }
 //# sourceMappingURL=incremental.js.map

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

@@ -1,14 +1,20 @@
 /**
  * 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.
+ * Stores per-file content hashes and optional cached output payloads.
+ * Persists to `.redscript-cache/cache.json`.
  */
 import type { HIRModule } from '../hir/types';
+import type { DatapackFile } from '../emit';
+export interface CachedOutputFile extends DatapackFile {
+}
 export interface CacheEntry {
     hash: string;
     mtime: number;
     hir?: HIRModule;
+    compiledFunctions?: string[];
+    outputFiles?: CachedOutputFile[];
+    dependencies?: string[];
 }
 export declare class FileCache {
     private entries;

package/dist/src/cache/index.js

@@ -2,8 +2,8 @@
 /**
  * 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.
+ * Stores per-file content hashes and optional cached output payloads.
+ * Persists to `.redscript-cache/cache.json`.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -117,12 +117,18 @@ class FileCache {
     save() {
         fs.mkdirSync(this.cacheDir, { recursive: true });
         const serialized = {
-            version: 1,
+            version: 2,
             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 };
+            serialized.entries[filePath] = {
+                hash: entry.hash,
+                mtime: entry.mtime,
+                compiledFunctions: entry.compiledFunctions,
+                outputFiles: entry.outputFiles,
+                dependencies: entry.dependencies,
+            };
         }
         const cachePath = path.join(this.cacheDir, 'cache.json');
         fs.writeFileSync(cachePath, JSON.stringify(serialized, null, 2));
@@ -132,10 +138,16 @@ class FileCache {
         const cachePath = path.join(this.cacheDir, 'cache.json');
         try {
             const data = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
-            if (data.version !== 1)
+            if (data.version !== 2)
                 return;
             for (const [filePath, entry] of Object.entries(data.entries)) {
-                this.entries.set(filePath, { hash: entry.hash, mtime: entry.mtime });
+                this.entries.set(filePath, {
+                    hash: entry.hash,
+                    mtime: entry.mtime,
+                    compiledFunctions: entry.compiledFunctions,
+                    outputFiles: entry.outputFiles,
+                    dependencies: entry.dependencies,
+                });
             }
         }
         catch {

package/dist/src/cli.d.ts

@@ -5,6 +5,7 @@
  * Usage:
  *   redscript compile <file> [-o <out>] [--namespace <ns>]
  *   redscript check <file>
+ *   redscript init [project-name]
  *   redscript repl
  *   redscript version
  */