redscript-mc 2.3.0 → 2.4.1

package/dist/src2/emit/index.js

@@ -0,0 +1,172 @@
+"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;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function emit(module, options) {
+    const { namespace } = options;
+    const tickFns = options.tickFunctions ?? [];
+    const loadFns = options.loadFunctions ?? [];
+    const objective = module.objective;
+    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 lines = emitFunction(fn, namespace, objective);
+        const fnPath = fnNameToPath(fn.name, namespace);
+        files.push({ path: fnPath, content: lines.join('\n') + '\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) {
+    const lines = [];
+    for (const instr of fn.instructions) {
+        lines.push(emitInstr(instr, namespace, objective));
+    }
+    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) {
+    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)}`;
+        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':
+            return `function ${instr.fn} with storage ${instr.storage}`;
+        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':
+            return `$${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 '>=';
+    }
+}
+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/src2/hir/lower.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AST → HIR Lowering — Stage 2 of the RedScript compiler pipeline.
+ *
+ * Desugaring transforms:
+ * - for(init;cond;step) → block { init; while(cond) { body; step } }
+ * - for_range(v,start,end) → block { let v = start; while(v < end) { body; v = v + 1 } }
+ * - a += b / -= / *= / /= / %= → a = a OP b
+ * - a && b → if(a) { b } else { false }
+ * - a || b → if(a) { true } else { b }
+ * - as_block / at_block / as_at → unified execute with subcommands
+ * - All other nodes pass through with field-wise recursion
+ */
+import type { Program } from '../../src/ast/types';
+import type { HIRModule } from './types';
+export declare function lowerToHIR(program: Program): HIRModule;

package/dist/src2/hir/lower.js

@@ -0,0 +1,378 @@
+"use strict";
+/**
+ * AST → HIR Lowering — Stage 2 of the RedScript compiler pipeline.
+ *
+ * Desugaring transforms:
+ * - for(init;cond;step) → block { init; while(cond) { body; step } }
+ * - for_range(v,start,end) → block { let v = start; while(v < end) { body; v = v + 1 } }
+ * - a += b / -= / *= / /= / %= → a = a OP b
+ * - a && b → if(a) { b } else { false }
+ * - a || b → if(a) { true } else { b }
+ * - as_block / at_block / as_at → unified execute with subcommands
+ * - All other nodes pass through with field-wise recursion
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowerToHIR = lowerToHIR;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function lowerToHIR(program) {
+    return {
+        namespace: program.namespace,
+        globals: program.globals.map(lowerGlobal),
+        functions: program.declarations.map(lowerFunction),
+        structs: program.structs.map((s) => ({
+            name: s.name,
+            fields: s.fields.map(f => ({ name: f.name, type: f.type })),
+            span: s.span,
+        })),
+        implBlocks: program.implBlocks.map((ib) => ({
+            typeName: ib.typeName,
+            methods: ib.methods.map(lowerFunction),
+            span: ib.span,
+        })),
+        enums: program.enums.map((e) => ({
+            name: e.name,
+            variants: e.variants.map(v => ({ name: v.name, value: v.value })),
+            span: e.span,
+        })),
+        consts: program.consts.map((c) => ({
+            name: c.name,
+            type: c.type,
+            value: lowerExpr(c.value),
+            span: c.span,
+        })),
+        isLibrary: program.isLibrary,
+    };
+}
+// ---------------------------------------------------------------------------
+// Functions & globals
+// ---------------------------------------------------------------------------
+function lowerGlobal(g) {
+    return {
+        name: g.name,
+        type: g.type,
+        init: lowerExpr(g.init),
+        mutable: g.mutable,
+        span: g.span,
+    };
+}
+function lowerFunction(fn) {
+    return {
+        name: fn.name,
+        params: fn.params.map(lowerParam),
+        returnType: fn.returnType,
+        decorators: fn.decorators,
+        body: lowerBlock(fn.body),
+        isLibraryFn: fn.isLibraryFn,
+        span: fn.span,
+    };
+}
+function lowerParam(p) {
+    return {
+        name: p.name,
+        type: p.type,
+        default: p.default ? lowerExpr(p.default) : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Blocks & statements
+// ---------------------------------------------------------------------------
+function lowerBlock(block) {
+    const result = [];
+    for (const stmt of block) {
+        const lowered = lowerStmt(stmt);
+        // lowerStmt may return an array (e.g. for → [init, while])
+        if (Array.isArray(lowered)) {
+            result.push(...lowered);
+        }
+        else {
+            result.push(lowered);
+        }
+    }
+    return result;
+}
+function lowerStmt(stmt) {
+    switch (stmt.kind) {
+        case 'let':
+            return { kind: 'let', name: stmt.name, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
+        case 'expr':
+            return { kind: 'expr', expr: lowerExpr(stmt.expr), span: stmt.span };
+        case 'return':
+            return { kind: 'return', value: stmt.value ? lowerExpr(stmt.value) : undefined, span: stmt.span };
+        case 'break':
+            return { kind: 'break', span: stmt.span };
+        case 'continue':
+            return { kind: 'continue', span: stmt.span };
+        case 'if':
+            return {
+                kind: 'if',
+                cond: lowerExpr(stmt.cond),
+                then: lowerBlock(stmt.then),
+                else_: stmt.else_ ? lowerBlock(stmt.else_) : undefined,
+                span: stmt.span,
+            };
+        case 'while':
+            return { kind: 'while', cond: lowerExpr(stmt.cond), body: lowerBlock(stmt.body), span: stmt.span };
+        // --- Desugaring: for → while ---
+        case 'for': {
+            const stmts = [];
+            // Init
+            if (stmt.init) {
+                const init = lowerStmt(stmt.init);
+                if (Array.isArray(init))
+                    stmts.push(...init);
+                else
+                    stmts.push(init);
+            }
+            // while(cond) { body } step { step_expr }
+            const body = lowerBlock(stmt.body);
+            const step = [{ kind: 'expr', expr: lowerExpr(stmt.step), span: stmt.span }];
+            stmts.push({ kind: 'while', cond: lowerExpr(stmt.cond), body, step, span: stmt.span });
+            return stmts;
+        }
+        // --- Desugaring: for_range → let + while(cond) { body } step { v++ } ---
+        case 'for_range': {
+            const varName = stmt.varName;
+            const initStmt = {
+                kind: 'let',
+                name: varName,
+                type: { kind: 'named', name: 'int' },
+                init: lowerExpr(stmt.start),
+                span: stmt.span,
+            };
+            const body = lowerBlock(stmt.body);
+            // step: v = v + 1 (in separate step block so continue still increments)
+            const step = [{
+                    kind: 'expr',
+                    expr: {
+                        kind: 'assign',
+                        target: varName,
+                        value: {
+                            kind: 'binary',
+                            op: '+',
+                            left: { kind: 'ident', name: varName },
+                            right: { kind: 'int_lit', value: 1 },
+                        },
+                    },
+                }];
+            const whileStmt = {
+                kind: 'while',
+                cond: {
+                    kind: 'binary',
+                    op: '<',
+                    left: { kind: 'ident', name: varName },
+                    right: lowerExpr(stmt.end),
+                },
+                body,
+                step,
+                span: stmt.span,
+            };
+            return [initStmt, whileStmt];
+        }
+        case 'foreach':
+            return {
+                kind: 'foreach',
+                binding: stmt.binding,
+                iterable: lowerExpr(stmt.iterable),
+                body: lowerBlock(stmt.body),
+                executeContext: stmt.executeContext,
+                span: stmt.span,
+            };
+        case 'match':
+            return {
+                kind: 'match',
+                expr: lowerExpr(stmt.expr),
+                arms: stmt.arms.map(arm => ({
+                    pattern: arm.pattern ? lowerExpr(arm.pattern) : null,
+                    body: lowerBlock(arm.body),
+                })),
+                span: stmt.span,
+            };
+        // --- Desugaring: as_block → execute [as] ---
+        case 'as_block':
+            return {
+                kind: 'execute',
+                subcommands: [{ kind: 'as', selector: stmt.selector }],
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
+        // --- Desugaring: at_block → execute [at] ---
+        case 'at_block':
+            return {
+                kind: 'execute',
+                subcommands: [{ kind: 'at', selector: stmt.selector }],
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
+        // --- Desugaring: as_at → execute [as, at] ---
+        case 'as_at':
+            return {
+                kind: 'execute',
+                subcommands: [
+                    { kind: 'as', selector: stmt.as_sel },
+                    { kind: 'at', selector: stmt.at_sel },
+                ],
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
+        case 'execute':
+            return {
+                kind: 'execute',
+                subcommands: stmt.subcommands.map(lowerExecuteSubcommand),
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
+        case 'raw':
+            return { kind: 'raw', cmd: stmt.cmd, span: stmt.span };
+        default: {
+            const _exhaustive = stmt;
+            throw new Error(`Unknown statement kind: ${_exhaustive.kind}`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Execute subcommands (pass-through — same shape)
+// ---------------------------------------------------------------------------
+function lowerExecuteSubcommand(sub) {
+    // All subcommand types share the same shape between AST and HIR
+    return sub;
+}
+// ---------------------------------------------------------------------------
+// Expressions
+// ---------------------------------------------------------------------------
+/** Map compound assignment operator to its base binary op */
+const COMPOUND_TO_BINOP = {
+    '+=': '+',
+    '-=': '-',
+    '*=': '*',
+    '/=': '/',
+    '%=': '%',
+};
+function lowerExpr(expr) {
+    switch (expr.kind) {
+        // --- Pass-through literals ---
+        case 'int_lit':
+        case 'float_lit':
+        case 'byte_lit':
+        case 'short_lit':
+        case 'long_lit':
+        case 'double_lit':
+        case 'bool_lit':
+        case 'str_lit':
+        case 'range_lit':
+        case 'rel_coord':
+        case 'local_coord':
+        case 'mc_name':
+        case 'blockpos':
+            return expr;
+        case 'ident':
+            return { kind: 'ident', name: expr.name, span: expr.span };
+        case 'selector':
+            return { kind: 'selector', raw: expr.raw, isSingle: expr.isSingle, sel: expr.sel, span: expr.span };
+        case 'array_lit':
+            return { kind: 'array_lit', elements: expr.elements.map(lowerExpr), span: expr.span };
+        case 'struct_lit':
+            return {
+                kind: 'struct_lit',
+                fields: expr.fields.map(f => ({ name: f.name, value: lowerExpr(f.value) })),
+                span: expr.span,
+            };
+        case 'str_interp':
+            return {
+                kind: 'str_interp',
+                parts: expr.parts.map(p => typeof p === 'string' ? p : lowerExpr(p)),
+                span: expr.span,
+            };
+        case 'f_string':
+            return { kind: 'f_string', parts: expr.parts, span: expr.span };
+        // Binary ops — && and || preserved as-is (short-circuit → control flow in MIR)
+        case 'binary':
+            return {
+                kind: 'binary',
+                op: expr.op,
+                left: lowerExpr(expr.left),
+                right: lowerExpr(expr.right),
+                span: expr.span,
+            };
+        case 'unary':
+            return { kind: 'unary', op: expr.op, operand: lowerExpr(expr.operand), span: expr.span };
+        case 'is_check':
+            return { kind: 'is_check', expr: lowerExpr(expr.expr), entityType: expr.entityType, span: expr.span };
+        // --- Desugaring: compound assignment → plain assign ---
+        case 'assign':
+            if (expr.op !== '=') {
+                const binOp = COMPOUND_TO_BINOP[expr.op];
+                return {
+                    kind: 'assign',
+                    target: expr.target,
+                    value: {
+                        kind: 'binary',
+                        op: binOp,
+                        left: { kind: 'ident', name: expr.target },
+                        right: lowerExpr(expr.value),
+                        span: expr.span,
+                    },
+                    span: expr.span,
+                };
+            }
+            return { kind: 'assign', target: expr.target, value: lowerExpr(expr.value), span: expr.span };
+        // --- Desugaring: compound member_assign → plain member_assign ---
+        case 'member_assign':
+            if (expr.op !== '=') {
+                const binOp = COMPOUND_TO_BINOP[expr.op];
+                const obj = lowerExpr(expr.obj);
+                return {
+                    kind: 'member_assign',
+                    obj,
+                    field: expr.field,
+                    value: {
+                        kind: 'binary',
+                        op: binOp,
+                        left: { kind: 'member', obj, field: expr.field },
+                        right: lowerExpr(expr.value),
+                        span: expr.span,
+                    },
+                    span: expr.span,
+                };
+            }
+            return {
+                kind: 'member_assign',
+                obj: lowerExpr(expr.obj),
+                field: expr.field,
+                value: lowerExpr(expr.value),
+                span: expr.span,
+            };
+        case 'member':
+            return { kind: 'member', obj: lowerExpr(expr.obj), field: expr.field, span: expr.span };
+        case 'index':
+            return { kind: 'index', obj: lowerExpr(expr.obj), index: lowerExpr(expr.index), span: expr.span };
+        case 'call':
+            return { kind: 'call', fn: expr.fn, args: expr.args.map(lowerExpr), span: expr.span };
+        case 'invoke':
+            return { kind: 'invoke', callee: lowerExpr(expr.callee), args: expr.args.map(lowerExpr), span: expr.span };
+        case 'static_call':
+            return {
+                kind: 'static_call',
+                type: expr.type,
+                method: expr.method,
+                args: expr.args.map(lowerExpr),
+                span: expr.span,
+            };
+        case 'lambda': {
+            const body = Array.isArray(expr.body) ? lowerBlock(expr.body) : lowerExpr(expr.body);
+            return {
+                kind: 'lambda',
+                params: expr.params,
+                returnType: expr.returnType,
+                body,
+                span: expr.span,
+            };
+        }
+        default: {
+            const _exhaustive = expr;
+            throw new Error(`Unknown expression kind: ${_exhaustive.kind}`);
+        }
+    }
+}
+//# sourceMappingURL=lower.js.map