redscript-mc 2.0.0 → 2.1.1

package/dist/src/compile.js

@@ -48,7 +48,7 @@ const diagnostics_1 = require("./diagnostics");
 // ---------------------------------------------------------------------------
 // Re-export v2 compile
 // ---------------------------------------------------------------------------
-var compile_1 = require("../src2/emit/compile");
+var compile_1 = require("./emit/compile");
 Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compile_1.compile; } });
 /**
  * Resolve a combined-source line number back to the original file and line.
@@ -75,6 +75,31 @@ function isLibrarySource(source) {
     }
     return false;
 }
+/** Resolve an import specifier to an absolute file path, trying multiple locations. */
+function resolveImportPath(spec, fromFile, includeDirs) {
+    const candidates = spec.endsWith('.mcrs') ? [spec] : [spec, spec + '.mcrs'];
+    for (const candidate of candidates) {
+        // 1. Relative to the importing file
+        const rel = path.resolve(path.dirname(fromFile), candidate);
+        if (fs.existsSync(rel))
+            return rel;
+        // 2. stdlib directory (package root / src / stdlib)
+        //    Strip leading 'stdlib/' prefix so `import "stdlib/math"` resolves to
+        //    <stdlibDir>/math.mcrs rather than <stdlibDir>/stdlib/math.mcrs.
+        const stdlibDir = path.resolve(__dirname, '..', 'src', 'stdlib');
+        const stdlibCandidate = candidate.replace(/^stdlib\//, '');
+        const stdlib = path.resolve(stdlibDir, stdlibCandidate);
+        if (fs.existsSync(stdlib))
+            return stdlib;
+        // 3. Extra include dirs
+        for (const dir of includeDirs) {
+            const extra = path.resolve(dir, candidate);
+            if (fs.existsSync(extra))
+                return extra;
+        }
+    }
+    return null;
+}
 function countLines(source) {
     return source === '' ? 0 : source.split('\n').length;
 }
@@ -88,6 +113,7 @@ function offsetRanges(ranges, lineOffset) {
 function preprocessSourceWithMetadata(source, options = {}) {
     const { filePath } = options;
     const seen = options.seen ?? new Set();
+    const includeDirs = options.includeDirs ?? [];
     if (filePath) {
         seen.add(path.resolve(filePath));
     }
@@ -105,27 +131,24 @@ function preprocessSourceWithMetadata(source, options = {}) {
             if (!filePath) {
                 throw new diagnostics_1.DiagnosticError('ParseError', 'Import statements require a file path', { line: i + 1, col: 1 }, lines);
             }
-            const importPath = path.resolve(path.dirname(filePath), match[1]);
+            const importPath = resolveImportPath(match[1], filePath, includeDirs);
+            if (!importPath) {
+                throw new diagnostics_1.DiagnosticError('ParseError', `Cannot import '${match[1]}'`, { file: filePath, line: i + 1, col: 1 }, lines);
+            }
             if (!seen.has(importPath)) {
                 seen.add(importPath);
-                let importedSource;
-                try {
-                    importedSource = fs.readFileSync(importPath, 'utf-8');
-                }
-                catch {
-                    throw new diagnostics_1.DiagnosticError('ParseError', `Cannot import '${match[1]}'`, { file: filePath, line: i + 1, col: 1 }, lines);
-                }
+                const importedSource = fs.readFileSync(importPath, 'utf-8');
                 if (isLibrarySource(importedSource)) {
                     // Library file: parse separately so its functions are DCE-eligible.
                     // Also collect any transitive library imports inside it.
-                    const nested = preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen });
+                    const nested = preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen, includeDirs });
                     libraryImports.push({ source: importedSource, filePath: importPath });
                     // Propagate transitive library imports (e.g. math.mcrs imports vec.mcrs)
                     if (nested.libraryImports)
                         libraryImports.push(...nested.libraryImports);
                 }
                 else {
-                    imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }));
+                    imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen, includeDirs }));
                 }
             }
             continue;

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

@@ -41,4 +41,4 @@ export declare class DiagnosticCollector {
  * e.g., "Expected ';' at line 5, col 12"
  */
 export declare function parseErrorMessage(kind: DiagnosticKind, rawMessage: string, sourceLines?: string[], filePath?: string): DiagnosticError;
-export declare function formatError(error: Error | DiagnosticError, source?: string): string;
+export declare function formatError(error: Error | DiagnosticError, source?: string, filePath?: string): string;

package/dist/src/diagnostics/index.js

@@ -116,25 +116,22 @@ function parseErrorMessage(kind, rawMessage, sourceLines, filePath) {
     // Fallback: line 1, col 1
     return new DiagnosticError(kind, rawMessage, { file: filePath, line: 1, col: 1 }, sourceLines);
 }
-function formatError(error, source) {
+function formatError(error, source, filePath) {
     if (error instanceof DiagnosticError) {
         const sourceLines = source?.split('\n') ?? error.sourceLines ?? [];
         const { file, line, col } = error.location;
-        const locationPart = file
-            ? ` in ${file} at line ${line}, col ${col}`
-            : ` at line ${line}, col ${col}`;
-        const lines = [`Error${locationPart}:`];
+        const fileStr = file ?? filePath ?? '<input>';
+        const header = `${fileStr}:${line}:${col}: error: ${error.message}`;
         const pointerLines = formatSourcePointer(sourceLines, line, col);
-        if (pointerLines.length > 0) {
-            lines.push(...pointerLines);
+        if (pointerLines.length === 0) {
+            return header;
         }
-        lines.push(error.message);
-        return lines.join('\n');
+        return [header, ...pointerLines].join('\n');
     }
     if (!source) {
         return error.message;
     }
-    const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'));
-    return formatError(parsed, source);
+    const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'), filePath);
+    return formatError(parsed, source, filePath);
 }
 //# sourceMappingURL=index.js.map

package/dist/src/emit/compile.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Top-level compile function for the v2 pipeline.
+ *
+ * Pipeline: source → Lexer → Parser → TypeCheck → HIR → MIR → optimize → LIR → emit
+ */
+import { type DatapackFile } from './index';
+import { McVersion } from '../types/mc-version';
+export interface CompileOptions {
+    namespace?: string;
+    filePath?: string;
+    /** v1 compat: inline library sources (treated as `module library;` imports) */
+    librarySources?: string[];
+    /** When true, generate .sourcemap.json files alongside .mcfunction output */
+    generateSourceMap?: boolean;
+    /** Target Minecraft version (default: 1.21). Affects which MC features are used. */
+    mcVersion?: McVersion;
+    /**
+     * When true, type errors are reported as warnings instead of blocking compilation.
+     * Use for gradual migration or testing with existing codebases that have type errors.
+     */
+    lenient?: boolean;
+    /** Extra directories to search when resolving imports (in addition to relative and stdlib). */
+    includeDirs?: string[];
+}
+export interface CompileResult {
+    files: DatapackFile[];
+    warnings: string[];
+    /** Always true — v1 compat shim (compile() throws on error) */
+    readonly success: true;
+}
+export declare function compile(source: string, options?: CompileOptions): CompileResult;

package/dist/src/emit/compile.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Top-level compile function for the v2 pipeline.
+ *
+ * Pipeline: source → Lexer → Parser → TypeCheck → HIR → MIR → optimize → LIR → emit
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const compile_1 = require("../compile");
+const diagnostics_1 = require("../diagnostics");
+const lower_1 = require("../hir/lower");
+const monomorphize_1 = require("../hir/monomorphize");
+const lower_2 = require("../mir/lower");
+const pipeline_1 = require("../optimizer/pipeline");
+const lower_3 = require("../lir/lower");
+const pipeline_2 = require("../optimizer/lir/pipeline");
+const index_1 = require("./index");
+const coroutine_1 = require("../optimizer/coroutine");
+const budget_1 = require("../lir/budget");
+const mc_version_1 = require("../types/mc-version");
+const typechecker_1 = require("../typechecker");
+function compile(source, options = {}) {
+    const { namespace = 'redscript', filePath, generateSourceMap = false, mcVersion = mc_version_1.DEFAULT_MC_VERSION, lenient = false, includeDirs } = options;
+    const warnings = [];
+    // Preprocess: resolve import directives, merge imported sources
+    const preprocessed = (0, compile_1.preprocessSourceWithMetadata)(source, { filePath, includeDirs });
+    const processedSource = preprocessed.source;
+    // Stage 1: Lex + Parse → AST
+    const lexer = new lexer_1.Lexer(processedSource);
+    const tokens = lexer.tokenize();
+    const parser = new parser_1.Parser(tokens, processedSource, filePath);
+    const ast = parser.parse(namespace);
+    // Merge library imports (files with `module library;`) into AST
+    for (const li of preprocessed.libraryImports ?? []) {
+        const libPreprocessed = (0, compile_1.preprocessSourceWithMetadata)(li.source, { filePath: li.filePath });
+        const libTokens = new lexer_1.Lexer(libPreprocessed.source, li.filePath).tokenize();
+        const libAst = new parser_1.Parser(libTokens, libPreprocessed.source, li.filePath).parse(namespace);
+        for (const fn of libAst.declarations)
+            fn.isLibraryFn = true;
+        ast.declarations.push(...libAst.declarations);
+        ast.structs.push(...libAst.structs);
+        ast.implBlocks.push(...libAst.implBlocks);
+        ast.enums.push(...libAst.enums);
+        ast.consts.push(...libAst.consts);
+        ast.globals.push(...libAst.globals);
+    }
+    // Merge librarySources (v1 compat: inline library strings) before HIR
+    if (options.librarySources) {
+        for (const libSrc of options.librarySources) {
+            const libTokens = new lexer_1.Lexer(libSrc).tokenize();
+            const libAst = new parser_1.Parser(libTokens, libSrc).parse(namespace);
+            for (const fn of libAst.declarations)
+                fn.isLibraryFn = true;
+            ast.declarations.push(...libAst.declarations);
+            ast.structs.push(...libAst.structs);
+            ast.implBlocks.push(...libAst.implBlocks);
+            ast.enums.push(...libAst.enums);
+            ast.consts.push(...libAst.consts);
+            ast.globals.push(...libAst.globals);
+        }
+    }
+    // Stage 1b: Type checking
+    // Run TypeChecker on the merged AST. In error-mode (default), throw on first type error.
+    // In lenient mode, demote type errors to warnings.
+    {
+        const checker = new typechecker_1.TypeChecker(processedSource, filePath);
+        const typeErrors = checker.check(ast);
+        if (typeErrors.length > 0) {
+            if (lenient) {
+                for (const e of typeErrors) {
+                    warnings.push(`[TypeError] line ${e.location.line}, col ${e.location.col}: ${e.message}`);
+                }
+            }
+            else {
+                throw typeErrors[0];
+            }
+        }
+    }
+    // Stage 2–7: lower, optimize, emit
+    // Wrap non-DiagnosticError from later stages so CLI always gets structured errors.
+    try {
+        // Stage 2: AST → HIR
+        const hirRaw = (0, lower_1.lowerToHIR)(ast);
+        // Stage 2b: Monomorphize generic functions
+        const hir = (0, monomorphize_1.monomorphize)(hirRaw);
+        // Extract @tick, @load, @coroutine, and @schedule functions from HIR (before decorator info is lost)
+        const tickFunctions = [];
+        const loadFunctions = [];
+        const coroutineInfos = [];
+        const scheduleFunctions = [];
+        for (const fn of hir.functions) {
+            for (const dec of fn.decorators) {
+                if (dec.name === 'tick')
+                    tickFunctions.push(fn.name);
+                if (dec.name === 'load')
+                    loadFunctions.push(fn.name);
+                if (dec.name === 'coroutine') {
+                    coroutineInfos.push({
+                        fnName: fn.name,
+                        batch: dec.args?.batch ?? 10,
+                        onDone: dec.args?.onDone,
+                    });
+                }
+                if (dec.name === 'schedule') {
+                    scheduleFunctions.push({ name: fn.name, ticks: dec.args?.ticks ?? 1 });
+                }
+            }
+        }
+        // Stage 3: HIR → MIR
+        const mir = (0, lower_2.lowerToMIR)(hir, filePath);
+        // Stage 4: MIR optimization
+        const mirOpt = (0, pipeline_1.optimizeModule)(mir);
+        // Stage 4b: Coroutine transform (opt-in, only for @coroutine functions)
+        const coroResult = (0, coroutine_1.coroutineTransform)(mirOpt, coroutineInfos);
+        const mirFinal = coroResult.module;
+        tickFunctions.push(...coroResult.generatedTickFunctions);
+        // Stage 5: MIR → LIR
+        const lir = (0, lower_3.lowerToLIR)(mirFinal);
+        // Stage 6: LIR optimization
+        const lirOpt = (0, pipeline_2.lirOptimizeModule)(lir);
+        // Static tick budget analysis
+        const coroutineNames = new Set(coroutineInfos.map(c => c.fnName));
+        const budgetDiags = (0, budget_1.analyzeBudget)(lirOpt, coroutineNames);
+        for (const diag of budgetDiags) {
+            if (diag.level === 'error') {
+                throw new diagnostics_1.DiagnosticError('LoweringError', diag.message, { line: 1, col: 1, file: filePath });
+            }
+            warnings.push(diag.message);
+        }
+        // Stage 7: LIR → .mcfunction
+        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion });
+        return { files, warnings, success: true };
+    }
+    catch (err) {
+        if (err instanceof diagnostics_1.DiagnosticError)
+            throw err;
+        const sourceLines = processedSource.split('\n');
+        throw (0, diagnostics_1.parseErrorMessage)('LoweringError', err.message, sourceLines, filePath);
+    }
+}
+//# sourceMappingURL=compile.js.map

package/dist/{src2 → src}/emit/index.d.ts

@@ -5,6 +5,7 @@
  * Each LIRFunction becomes a .mcfunction file under data/<ns>/function/.
  */
 import type { LIRModule } from '../lir/types';
+import { McVersion } from '../types/mc-version';
 export interface DatapackFile {
     path: string;
     content: string;
@@ -13,5 +14,13 @@ export interface EmitOptions {
     namespace: string;
     tickFunctions?: string[];
     loadFunctions?: string[];
+    scheduleFunctions?: Array<{
+        name: string;
+        ticks: number;
+    }>;
+    /** When true, generate a .sourcemap.json sidecar file for each .mcfunction */
+    generateSourceMap?: boolean;
+    /** Target Minecraft version; controls which MC features are used in codegen */
+    mcVersion?: McVersion;
 }
 export declare function emit(module: LIRModule, options: EmitOptions): DatapackFile[];

package/dist/{src2 → src}/emit/index.js

@@ -7,6 +7,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emit = emit;
+const sourcemap_1 = require("./sourcemap");
+const mc_version_1 = require("../types/mc-version");
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -14,7 +16,10 @@ function emit(module, options) {
     const { namespace } = options;
     const tickFns = options.tickFunctions ?? [];
     const loadFns = options.loadFunctions ?? [];
+    const scheduleFns = options.scheduleFunctions ?? [];
     const objective = module.objective;
+    const genSourceMap = options.generateSourceMap ?? false;
+    const mcVersion = options.mcVersion ?? mc_version_1.DEFAULT_MC_VERSION;
     const files = [];
     // pack.mcmeta
     files.push({
@@ -31,9 +36,27 @@ function emit(module, options) {
     });
     // Each LIR function → .mcfunction file
     for (const fn of module.functions) {
-        const lines = emitFunction(fn, namespace, objective);
         const fnPath = fnNameToPath(fn.name, namespace);
-        files.push({ path: fnPath, content: lines.join('\n') + '\n' });
+        if (genSourceMap) {
+            const builder = new sourcemap_1.SourceMapBuilder(fnPath);
+            const lines = emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion);
+            files.push({ path: fnPath, content: lines.join('\n') + '\n' });
+            const map = builder.build();
+            if (map) {
+                files.push({ path: (0, sourcemap_1.sourceMapPath)(fnPath), content: (0, sourcemap_1.serializeSourceMap)(map) });
+            }
+        }
+        else {
+            const lines = emitFunction(fn, namespace, objective, mcVersion);
+            files.push({ path: fnPath, content: lines.join('\n') + '\n' });
+        }
+    }
+    // @schedule wrapper functions: _schedule_xxx → schedule function ns:xxx Nt
+    for (const { name, ticks } of scheduleFns) {
+        files.push({
+            path: `data/${namespace}/function/_schedule_${name}.mcfunction`,
+            content: `schedule function ${namespace}:${name} ${ticks}t\n`,
+        });
     }
     // Tag files for tick/load
     if (loadFns.length > 0 || true) {
@@ -56,10 +79,18 @@ function emit(module, options) {
 // ---------------------------------------------------------------------------
 // Function emission
 // ---------------------------------------------------------------------------
-function emitFunction(fn, namespace, objective) {
+function emitFunction(fn, namespace, objective, mcVersion) {
+    const lines = [];
+    for (const instr of fn.instructions) {
+        lines.push(emitInstr(instr, namespace, objective, mcVersion));
+    }
+    return lines;
+}
+function emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion) {
     const lines = [];
     for (const instr of fn.instructions) {
-        lines.push(emitInstr(instr, namespace, objective));
+        lines.push(emitInstr(instr, namespace, objective, mcVersion));
+        builder.addLine(instr.sourceLoc);
     }
     return lines;
 }
@@ -71,7 +102,7 @@ function fnNameToPath(name, namespace) {
 // ---------------------------------------------------------------------------
 // Instruction emission
 // ---------------------------------------------------------------------------
-function emitInstr(instr, ns, obj) {
+function emitInstr(instr, ns, obj, mcVersion) {
     switch (instr.kind) {
         case 'score_set':
             return `scoreboard players set ${slot(instr.dst)} ${instr.value}`;
@@ -94,7 +125,7 @@ function emitInstr(instr, ns, obj) {
         case 'score_swap':
             return `scoreboard players operation ${slot(instr.a)} >< ${slot(instr.b)}`;
         case 'store_cmd_to_score':
-            return `execute store result score ${slot(instr.dst)} run ${emitInstr(instr.cmd, ns, obj)}`;
+            return `execute store result score ${slot(instr.dst)} run ${emitInstr(instr.cmd, ns, obj, mcVersion)}`;
         case 'store_score_to_nbt':
             return `execute store result storage ${instr.ns} ${instr.path} ${instr.type} ${instr.scale} run scoreboard players get ${slot(instr.src)}`;
         case 'store_nbt_to_score':
@@ -106,7 +137,11 @@ function emitInstr(instr, ns, obj) {
         case 'call':
             return `function ${instr.fn}`;
         case 'call_macro':
-            return `function ${instr.fn} with storage ${instr.storage}`;
+            if (mcVersion >= mc_version_1.McVersion.v1_20_2) {
+                return `function ${instr.fn} with storage ${instr.storage}`;
+            }
+            // Pre-1.20.2: macros not supported; call function directly (args in storage are ignored)
+            return `function ${instr.fn}`;
         case 'call_if_matches':
             return `execute if score ${slot(instr.slot)} matches ${instr.range} run function ${instr.fn}`;
         case 'call_unless_matches':
@@ -122,7 +157,13 @@ function emitInstr(instr, ns, obj) {
         case 'return_value':
             return `scoreboard players operation $ret ${instr.slot.obj} = ${slot(instr.slot)}`;
         case 'macro_line':
-            return `$${instr.template}`;
+            if (mcVersion >= mc_version_1.McVersion.v1_20_2) {
+                return `$${instr.template}`;
+            }
+            // Pre-1.20.2: function macros not available. Emit as a plain command with
+            // $(param) placeholders replaced by storage reads via data get (best-effort
+            // compat for string/id params; numeric coords will not be dynamic).
+            return macroLineCompat(instr.template);
         case 'raw':
             return instr.cmd;
     }
@@ -143,6 +184,16 @@ function cmpToMC(op) {
         case 'ge': return '>=';
     }
 }
+/**
+ * Pre-1.20.2 compat: emit a macro template as a plain command.
+ * $(param) placeholders are replaced with `storage rs:macro_args <param>` data-get
+ * expressions for string/id values, or left as literal "0" for coordinates.
+ * This is best-effort — dynamic numeric positions cannot be truly emulated.
+ */
+function macroLineCompat(template) {
+    // Replace $(param) with data-get-style substitution marker
+    return template.replace(/\$\((\w+)\)/g, (_m, p) => `{storage:rs:macro_args,path:${p}}`);
+}
 function emitSubcmd(sub) {
     switch (sub.kind) {
         case 'as':

package/dist/src/emit/modules.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Phase 5b — Multi-Module Compilation
+ *
+ * Compiles multiple .mcrs files that use `module <name>;` / `import <mod>::<sym>;`
+ * into a single datapack with namespace-isolated scoreboards and correct cross-module
+ * function paths.
+ *
+ * Design:
+ * - Each module gets its own scoreboard objective: `__${namespace}_${moduleName}`
+ * - Cross-module function calls are emitted as `${namespace}:${moduleName}/${fnName}`
+ * - DCE: exported-but-never-imported functions are stripped from the output
+ * - Circular imports are detected and rejected
+ */
+import { type DatapackFile } from './index';
+export interface ModuleInput {
+    /** Module name (must match the `module <name>;` declaration in source, or be inferred) */
+    name: string;
+    source: string;
+    filePath?: string;
+}
+export interface CompileModulesOptions {
+    /** Datapack namespace (e.g. "mypack") */
+    namespace?: string;
+}
+export interface CompileModulesResult {
+    files: DatapackFile[];
+    warnings: string[];
+}
+export declare function compileModules(modules: ModuleInput[], options?: CompileModulesOptions): CompileModulesResult;