redscript-mc 1.2.30 → 2.1.0

package/dist/{diagnostics → 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,29 @@
+/**
+ * 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;
+}
+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 } = options;
+    const warnings = [];
+    // Preprocess: resolve import directives, merge imported sources
+    const preprocessed = (0, compile_1.preprocessSourceWithMetadata)(source, { filePath });
+    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/src/emit/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Stage 7 — LIR → .mcfunction Emission
+ *
+ * Converts a LIRModule into DatapackFile[] representing a Minecraft datapack.
+ * 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;
+}
+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/src/emit/index.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Stage 7 — LIR → .mcfunction Emission
+ *
+ * Converts a LIRModule into DatapackFile[] representing a Minecraft datapack.
+ * Each LIRFunction becomes a .mcfunction file under data/<ns>/function/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emit = emit;
+const sourcemap_1 = require("./sourcemap");
+const mc_version_1 = require("../types/mc-version");
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+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({
+        path: 'pack.mcmeta',
+        content: JSON.stringify({
+            pack: { pack_format: 26, description: `RedScript datapack: ${namespace}` },
+        }, null, 2) + '\n',
+    });
+    // load.mcfunction — creates the scoreboard objective
+    const loadCmds = [`scoreboard objectives add ${objective} dummy`];
+    files.push({
+        path: `data/${namespace}/function/load.mcfunction`,
+        content: loadCmds.join('\n') + '\n',
+    });
+    // Each LIR function → .mcfunction file
+    for (const fn of module.functions) {
+        const fnPath = fnNameToPath(fn.name, namespace);
+        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) {
+        // Always include load.json — it must reference the load.mcfunction
+        const loadValues = [`${namespace}:load`, ...loadFns.map(fn => `${namespace}:${fn}`)];
+        files.push({
+            path: 'data/minecraft/tags/function/load.json',
+            content: JSON.stringify({ values: loadValues }, null, 2) + '\n',
+        });
+    }
+    if (tickFns.length > 0) {
+        const tickValues = tickFns.map(fn => `${namespace}:${fn}`);
+        files.push({
+            path: 'data/minecraft/tags/function/tick.json',
+            content: JSON.stringify({ values: tickValues }, null, 2) + '\n',
+        });
+    }
+    return files;
+}
+// ---------------------------------------------------------------------------
+// Function emission
+// ---------------------------------------------------------------------------
+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, mcVersion));
+        builder.addLine(instr.sourceLoc);
+    }
+    return lines;
+}
+function fnNameToPath(name, namespace) {
+    // LIR function names may contain :: for methods — convert to /
+    const mcName = name.replace(/::/g, '/').toLowerCase();
+    return `data/${namespace}/function/${mcName}.mcfunction`;
+}
+// ---------------------------------------------------------------------------
+// Instruction emission
+// ---------------------------------------------------------------------------
+function emitInstr(instr, ns, obj, mcVersion) {
+    switch (instr.kind) {
+        case 'score_set':
+            return `scoreboard players set ${slot(instr.dst)} ${instr.value}`;
+        case 'score_copy':
+            return `scoreboard players operation ${slot(instr.dst)} = ${slot(instr.src)}`;
+        case 'score_add':
+            return `scoreboard players operation ${slot(instr.dst)} += ${slot(instr.src)}`;
+        case 'score_sub':
+            return `scoreboard players operation ${slot(instr.dst)} -= ${slot(instr.src)}`;
+        case 'score_mul':
+            return `scoreboard players operation ${slot(instr.dst)} *= ${slot(instr.src)}`;
+        case 'score_div':
+            return `scoreboard players operation ${slot(instr.dst)} /= ${slot(instr.src)}`;
+        case 'score_mod':
+            return `scoreboard players operation ${slot(instr.dst)} %= ${slot(instr.src)}`;
+        case 'score_min':
+            return `scoreboard players operation ${slot(instr.dst)} < ${slot(instr.src)}`;
+        case 'score_max':
+            return `scoreboard players operation ${slot(instr.dst)} > ${slot(instr.src)}`;
+        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, 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':
+            return `execute store result score ${slot(instr.dst)} run data get storage ${instr.ns} ${instr.path} ${instr.scale}`;
+        case 'nbt_set_literal':
+            return `data modify storage ${instr.ns} ${instr.path} set value ${instr.value}`;
+        case 'nbt_copy':
+            return `data modify storage ${instr.dstNs} ${instr.dstPath} set from storage ${instr.srcNs} ${instr.srcPath}`;
+        case 'call':
+            return `function ${instr.fn}`;
+        case 'call_macro':
+            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':
+            return `execute unless score ${slot(instr.slot)} matches ${instr.range} run function ${instr.fn}`;
+        case 'call_if_score':
+            return `execute if score ${slot(instr.a)} ${cmpToMC(instr.op)} ${slot(instr.b)} run function ${instr.fn}`;
+        case 'call_unless_score':
+            return `execute unless score ${slot(instr.a)} ${cmpToMC(instr.op)} ${slot(instr.b)} run function ${instr.fn}`;
+        case 'call_context': {
+            const subcmds = instr.subcommands.map(emitSubcmd).join(' ');
+            return `execute ${subcmds} run function ${instr.fn}`;
+        }
+        case 'return_value':
+            return `scoreboard players operation $ret ${instr.slot.obj} = ${slot(instr.slot)}`;
+        case 'macro_line':
+            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;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function slot(s) {
+    return `${s.player} ${s.obj}`;
+}
+function cmpToMC(op) {
+    switch (op) {
+        case 'eq': return '=';
+        case 'ne': return '='; // ne uses "unless" form, but when used in if score context
+        case 'lt': return '<';
+        case 'le': return '<=';
+        case 'gt': return '>';
+        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':
+            return `as ${sub.selector}`;
+        case 'at':
+            return `at ${sub.selector}`;
+        case 'at_self':
+            return 'at @s';
+        case 'positioned':
+            return `positioned ${sub.x} ${sub.y} ${sub.z}`;
+        case 'rotated':
+            return `rotated ${sub.yaw} ${sub.pitch}`;
+        case 'in':
+            return `in ${sub.dimension}`;
+        case 'anchored':
+            return `anchored ${sub.anchor}`;
+        case 'if_score':
+            return `if score ${sub.a} ${cmpToMC(sub.op)} ${sub.b}`;
+        case 'unless_score':
+            return `unless score ${sub.a} ${cmpToMC(sub.op)} ${sub.b}`;
+        case 'if_matches':
+            return `if score ${sub.score} matches ${sub.range}`;
+        case 'unless_matches':
+            return `unless score ${sub.score} matches ${sub.range}`;
+    }
+}
+//# sourceMappingURL=index.js.map

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;