redscript-mc 1.2.12 → 1.2.14

package/dist/lowering/index.js

@@ -45,6 +45,16 @@ const diagnostics_1 = require("../diagnostics");
 const path = __importStar(require("path"));
 const types_1 = require("../events/types");
 // ---------------------------------------------------------------------------
+// Macro-aware builtins (MC 1.20.2+)
+// These builtins generate commands where parameter variables cannot appear
+// as literal values (coordinates, entity types, block types), so they
+// require MC macro syntax when called with runtime variables.
+// ---------------------------------------------------------------------------
+const MACRO_AWARE_BUILTINS = new Set([
+    'summon', 'particle', 'setblock', 'fill', 'clone',
+    'playsound', 'tp', 'tp_to', 'effect', 'effect_clear', 'give',
+]);
+// ---------------------------------------------------------------------------
 // Builtin Functions
 // ---------------------------------------------------------------------------
 const BUILTINS = {
@@ -213,12 +223,194 @@ class Lowering {
         this.worldObjCounter = 0;
         // Loop context stack for break/continue
         this.loopStack = [];
+        // MC 1.20.2+ macro function support
+        // Names of params in the current function being lowered
+        this.currentFnParamNames = new Set();
+        // Params in the current function that need macro treatment (used in literal positions)
+        this.currentFnMacroParams = new Set();
+        // Global registry: fnName → macroParamNames (populated by pre-scan + lowering)
+        this.macroFunctionInfo = new Map();
         this.namespace = namespace;
         this.sourceRanges = sourceRanges;
         LoweringBuilder.resetTempCounter();
     }
+    // ---------------------------------------------------------------------------
+    // MC Macro pre-scan: identify which function params need macro treatment
+    // ---------------------------------------------------------------------------
+    preScanMacroFunctions(program) {
+        for (const fn of program.declarations) {
+            const paramNames = new Set(fn.params.map(p => p.name));
+            const macroParams = new Set();
+            this.preScanStmts(fn.body, paramNames, macroParams);
+            if (macroParams.size > 0) {
+                this.macroFunctionInfo.set(fn.name, [...macroParams]);
+            }
+        }
+        for (const implBlock of program.implBlocks ?? []) {
+            for (const method of implBlock.methods) {
+                const paramNames = new Set(method.params.map(p => p.name));
+                const macroParams = new Set();
+                this.preScanStmts(method.body, paramNames, macroParams);
+                if (macroParams.size > 0) {
+                    this.macroFunctionInfo.set(`${implBlock.typeName}_${method.name}`, [...macroParams]);
+                }
+            }
+        }
+    }
+    preScanStmts(stmts, paramNames, macroParams) {
+        for (const stmt of stmts) {
+            this.preScanStmt(stmt, paramNames, macroParams);
+        }
+    }
+    preScanStmt(stmt, paramNames, macroParams) {
+        switch (stmt.kind) {
+            case 'expr':
+                this.preScanExpr(stmt.expr, paramNames, macroParams);
+                break;
+            case 'let':
+                this.preScanExpr(stmt.init, paramNames, macroParams);
+                break;
+            case 'return':
+                if (stmt.value)
+                    this.preScanExpr(stmt.value, paramNames, macroParams);
+                break;
+            case 'if':
+                this.preScanExpr(stmt.cond, paramNames, macroParams);
+                this.preScanStmts(stmt.then, paramNames, macroParams);
+                if (stmt.else_)
+                    this.preScanStmts(stmt.else_, paramNames, macroParams);
+                break;
+            case 'while':
+                this.preScanExpr(stmt.cond, paramNames, macroParams);
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'for':
+                if (stmt.init)
+                    this.preScanStmt(stmt.init, paramNames, macroParams);
+                this.preScanExpr(stmt.cond, paramNames, macroParams);
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'for_range':
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'foreach':
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'match':
+                this.preScanExpr(stmt.expr, paramNames, macroParams);
+                for (const arm of stmt.arms) {
+                    this.preScanStmts(arm.body, paramNames, macroParams);
+                }
+                break;
+            case 'as_block':
+            case 'at_block':
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'execute':
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            // raw, break, continue have no nested exprs of interest
+        }
+    }
+    preScanExpr(expr, paramNames, macroParams) {
+        if (expr.kind === 'call' && MACRO_AWARE_BUILTINS.has(expr.fn)) {
+            // All ident args to macro-aware builtins that are params → macro params
+            for (const arg of expr.args) {
+                if (arg.kind === 'ident' && paramNames.has(arg.name)) {
+                    macroParams.add(arg.name);
+                }
+            }
+            return;
+        }
+        // Recurse into sub-expressions for other call types
+        if (expr.kind === 'call') {
+            for (const arg of expr.args)
+                this.preScanExpr(arg, paramNames, macroParams);
+        }
+        else if (expr.kind === 'binary') {
+            this.preScanExpr(expr.left, paramNames, macroParams);
+            this.preScanExpr(expr.right, paramNames, macroParams);
+        }
+        else if (expr.kind === 'unary') {
+            this.preScanExpr(expr.operand, paramNames, macroParams);
+        }
+        else if (expr.kind === 'assign') {
+            this.preScanExpr(expr.value, paramNames, macroParams);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Macro helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * If `expr` is a function parameter that needs macro treatment (runtime value
+     * used in a literal position), returns the param name; otherwise null.
+     */
+    tryGetMacroParam(expr) {
+        if (expr.kind !== 'ident')
+            return null;
+        if (!this.currentFnParamNames.has(expr.name))
+            return null;
+        if (this.constValues.has(expr.name))
+            return null;
+        if (this.stringValues.has(expr.name))
+            return null;
+        return expr.name;
+    }
+    /**
+     * Converts an expression to a string for use as a builtin arg.
+     * If the expression is a macro param, returns `$(name)` and sets macroParam.
+     */
+    exprToBuiltinArg(expr) {
+        const macroParam = this.tryGetMacroParam(expr);
+        if (macroParam) {
+            return { str: `$(${macroParam})`, macroParam };
+        }
+        if (expr.kind === 'struct_lit' || expr.kind === 'array_lit') {
+            return { str: this.exprToSnbt(expr) };
+        }
+        return { str: this.exprToString(expr) };
+    }
+    /**
+     * Emits a call to a macro function, setting up both scoreboard params
+     * (for arithmetic use) and NBT macro args (for coordinate/literal use).
+     */
+    emitMacroFunctionCall(fnName, args, macroParamNames, fnDecl) {
+        const params = fnDecl?.params ?? [];
+        const loweredArgs = args.map(arg => this.lowerExpr(arg));
+        // Set up regular scoreboard params (for arithmetic within the function)
+        for (let i = 0; i < loweredArgs.length; i++) {
+            const operand = loweredArgs[i];
+            if (operand.kind === 'const') {
+                this.builder.emitRaw(`scoreboard players set $p${i} rs ${operand.value}`);
+            }
+            else if (operand.kind === 'var') {
+                this.builder.emitRaw(`scoreboard players operation $p${i} rs = ${operand.name} rs`);
+            }
+        }
+        // Set up NBT storage for each macro param
+        for (const macroParam of macroParamNames) {
+            const paramIdx = params.findIndex(p => p.name === macroParam);
+            if (paramIdx < 0 || paramIdx >= loweredArgs.length)
+                continue;
+            const operand = loweredArgs[paramIdx];
+            if (operand.kind === 'const') {
+                this.builder.emitRaw(`data modify storage rs:macro_args ${macroParam} set value ${operand.value}`);
+            }
+            else if (operand.kind === 'var') {
+                this.builder.emitRaw(`execute store result storage rs:macro_args ${macroParam} int 1 run scoreboard players get ${operand.name} rs`);
+            }
+        }
+        // Call with macro storage
+        this.builder.emitRaw(`function ${this.namespace}:${fnName} with storage rs:macro_args`);
+        // Copy return value (callers may use it)
+        const dst = this.builder.freshTemp();
+        this.builder.emitRaw(`scoreboard players operation ${dst} rs = $ret rs`);
+        return { kind: 'var', name: dst };
+    }
     lower(program) {
         this.namespace = program.namespace;
+        // Pre-scan for macro functions before main lowering (so call sites can detect them)
+        this.preScanMacroFunctions(program);
         // Load struct definitions
         for (const struct of program.structs ?? []) {
             const fields = new Map();
@@ -297,6 +489,9 @@ class Lowering {
         this.blockPosVars = new Map();
         this.stringValues = new Map();
         this.builder = new LoweringBuilder();
+        // Initialize macro tracking for this function
+        this.currentFnParamNames = new Set(runtimeParams.map(p => p.name));
+        this.currentFnMacroParams = new Set();
         // Map parameters
         if (staticEventDec) {
             for (let i = 0; i < fn.params.length; i++) {
@@ -401,6 +596,13 @@ class Lowering {
         if (tickRate && tickRate > 1) {
             this.wrapWithTickRate(irFn, tickRate);
         }
+        // Set macro metadata if this function uses MC macro syntax
+        if (this.currentFnMacroParams.size > 0) {
+            irFn.isMacroFunction = true;
+            irFn.macroParamNames = [...this.currentFnMacroParams];
+            // Update registry (may refine the pre-scan result)
+            this.macroFunctionInfo.set(loweredName, irFn.macroParamNames);
+        }
         this.functions.push(irFn);
     }
     getTickRate(decorators) {
@@ -1588,8 +1790,18 @@ class Lowering {
             const targetFn = callbackBindings.size > 0 || stdlibCallSite
                 ? this.ensureSpecializedFunctionWithContext(fnDecl, callbackBindings, stdlibCallSite)
                 : expr.fn;
+            // Check if this is a call to a known macro function
+            const macroParams = this.macroFunctionInfo.get(targetFn);
+            if (macroParams && macroParams.length > 0) {
+                return this.emitMacroFunctionCall(targetFn, runtimeArgs, macroParams, fnDecl);
+            }
             return this.emitDirectFunctionCall(targetFn, runtimeArgs);
         }
+        // Check for macro function (forward-declared or external)
+        const macroParamsForUnknown = this.macroFunctionInfo.get(expr.fn);
+        if (macroParamsForUnknown && macroParamsForUnknown.length > 0) {
+            return this.emitMacroFunctionCall(expr.fn, fullArgs, macroParamsForUnknown, undefined);
+        }
         return this.emitDirectFunctionCall(expr.fn, fullArgs);
     }
     lowerStaticCallExpr(expr) {
@@ -1718,6 +1930,9 @@ class Lowering {
         const savedBlockPosVars = new Map(this.blockPosVars);
         const savedStringValues = new Map(this.stringValues);
         const savedVarTypes = new Map(this.varTypes);
+        // Macro tracking state
+        const savedCurrentFnParamNames = new Set(this.currentFnParamNames);
+        const savedCurrentFnMacroParams = new Set(this.currentFnMacroParams);
         try {
             return callback();
         }
@@ -1734,6 +1949,8 @@ class Lowering {
             this.blockPosVars = savedBlockPosVars;
             this.stringValues = savedStringValues;
             this.varTypes = savedVarTypes;
+            this.currentFnParamNames = savedCurrentFnParamNames;
+            this.currentFnMacroParams = savedCurrentFnMacroParams;
         }
     }
     lowerBuiltinCall(name, args, callSpan) {
@@ -1967,16 +2184,31 @@ class Lowering {
                 code: 'W_DEPRECATED',
                 ...(callSpan ? { line: callSpan.line, col: callSpan.col } : {}),
             });
-            const tpCommand = this.lowerTpCommand(args);
-            if (tpCommand) {
-                this.builder.emitRaw(tpCommand);
+            const tpResult = this.lowerTpCommandMacroAware(args);
+            if (tpResult) {
+                this.builder.emitRaw(tpResult.cmd);
             }
             return { kind: 'const', value: 0 };
         }
         if (name === 'tp') {
-            const tpCommand = this.lowerTpCommand(args);
-            if (tpCommand) {
-                this.builder.emitRaw(tpCommand);
+            const tpResult = this.lowerTpCommandMacroAware(args);
+            if (tpResult) {
+                this.builder.emitRaw(tpResult.cmd);
+            }
+            return { kind: 'const', value: 0 };
+        }
+        // For macro-aware builtins, check if any arg is a param needing macro treatment
+        if (MACRO_AWARE_BUILTINS.has(name)) {
+            const argResults = args.map(arg => this.exprToBuiltinArg(arg));
+            const hasMacroArg = argResults.some(r => r.macroParam !== undefined);
+            if (hasMacroArg) {
+                argResults.forEach(r => { if (r.macroParam)
+                    this.currentFnMacroParams.add(r.macroParam); });
+            }
+            const strArgs = argResults.map(r => r.str);
+            const cmd = BUILTINS[name]?.(strArgs);
+            if (cmd) {
+                this.builder.emitRaw(hasMacroArg ? `$${cmd}` : cmd);
             }
             return { kind: 'const', value: 0 };
         }
@@ -2488,6 +2720,36 @@ class Lowering {
         }
         return null;
     }
+    lowerTpCommandMacroAware(args) {
+        const pos0 = args[0] ? this.resolveBlockPosExpr(args[0]) : null;
+        const pos1 = args[1] ? this.resolveBlockPosExpr(args[1]) : null;
+        // If blockpos args are used, no macro needed (coords are already resolved)
+        if (args.length === 1 && pos0) {
+            return { cmd: `tp ${emitBlockPos(pos0)}` };
+        }
+        if (args.length === 2 && pos1) {
+            return { cmd: `tp ${this.exprToString(args[0])} ${emitBlockPos(pos1)}` };
+        }
+        // Check for macro args (int params used as coordinates)
+        if (args.length >= 2) {
+            const argResults = args.map(a => this.exprToBuiltinArg(a));
+            const hasMacro = argResults.some(r => r.macroParam !== undefined);
+            if (hasMacro) {
+                argResults.forEach(r => { if (r.macroParam)
+                    this.currentFnMacroParams.add(r.macroParam); });
+                const strs = argResults.map(r => r.str);
+                if (args.length === 2) {
+                    return { cmd: `$tp ${strs[0]} ${strs[1]}` };
+                }
+                if (args.length === 4) {
+                    return { cmd: `$tp ${strs[0]} ${strs[1]} ${strs[2]} ${strs[3]}` };
+                }
+            }
+        }
+        // Fallback to non-macro
+        const plain = this.lowerTpCommand(args);
+        return plain ? { cmd: plain } : null;
+    }
     resolveBlockPosExpr(expr) {
         if (expr.kind === 'blockpos') {
             return expr;

package/dist/optimizer/commands.d.ts

@@ -9,6 +9,7 @@ export interface OptimizationStats {
     setblockSavedCommands: number;
     deadCodeRemoved: number;
     constantFolds: number;
+    inlinedTrivialFunctions: number;
     totalCommandsBefore: number;
     totalCommandsAfter: number;
 }

package/dist/optimizer/commands.js

@@ -23,6 +23,7 @@ function createEmptyOptimizationStats() {
         setblockSavedCommands: 0,
         deadCodeRemoved: 0,
         constantFolds: 0,
+        inlinedTrivialFunctions: 0,
         totalCommandsBefore: 0,
         totalCommandsAfter: 0,
     };
@@ -330,11 +331,105 @@ function batchSetblocks(functions) {
     stats.totalCommandsAfter = optimized.reduce((sum, fn) => sum + fn.commands.length, 0);
     return { functions: optimized, stats };
 }
+/**
+ * Inline trivial functions:
+ * 1. Functions that only contain a single `function` call → inline the call
+ * 2. Empty functions (no commands) → remove and eliminate all calls to them
+ */
+function inlineTrivialFunctions(functions) {
+    const FUNCTION_CMD_RE = /^function ([^:]+):(.+)$/;
+    // Find trivial functions (only a single function call, no other commands)
+    const trivialMap = new Map(); // fn name -> target fn name
+    const emptyFunctions = new Set(); // functions with no commands
+    // System functions that should never be removed
+    const SYSTEM_FUNCTIONS = new Set(['__tick', '__load']);
+    for (const fn of functions) {
+        // Never remove system functions
+        if (SYSTEM_FUNCTIONS.has(fn.name) || fn.name.startsWith('__trigger_')) {
+            continue;
+        }
+        const nonCommentCmds = fn.commands.filter(cmd => !cmd.cmd.startsWith('#'));
+        if (nonCommentCmds.length === 0 && fn.name.includes('/')) {
+            // Empty control-flow block (e.g., main/merge_5) - mark for removal
+            // Only remove if it's a sub-block (contains /), not a top-level function
+            emptyFunctions.add(fn.name);
+        }
+        else if (nonCommentCmds.length === 1 && fn.name.includes('/')) {
+            const match = nonCommentCmds[0].cmd.match(FUNCTION_CMD_RE);
+            if (match) {
+                // This function only calls another function
+                trivialMap.set(fn.name, match[2]);
+            }
+        }
+    }
+    // Resolve chains: if A -> B -> C, then A -> C
+    // Also handle: A -> B where B is empty → A is effectively empty
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [from, to] of trivialMap) {
+            if (emptyFunctions.has(to)) {
+                // Target is empty, so this function is effectively empty too
+                trivialMap.delete(from);
+                emptyFunctions.add(from);
+                changed = true;
+            }
+            else {
+                const finalTarget = trivialMap.get(to);
+                if (finalTarget && finalTarget !== to) {
+                    trivialMap.set(from, finalTarget);
+                    changed = true;
+                }
+            }
+        }
+    }
+    const totalRemoved = trivialMap.size + emptyFunctions.size;
+    if (totalRemoved === 0) {
+        return { functions, stats: {} };
+    }
+    // Set of all functions to remove
+    const removedNames = new Set([...trivialMap.keys(), ...emptyFunctions]);
+    // Rewrite all function calls to skip trivial wrappers or remove empty calls
+    const result = [];
+    for (const fn of functions) {
+        // Skip removed functions
+        if (removedNames.has(fn.name)) {
+            continue;
+        }
+        // Rewrite function calls in this function
+        const rewrittenCmds = [];
+        for (const cmd of fn.commands) {
+            // Check if this is a call to an empty function
+            const emptyCallMatch = cmd.cmd.match(/^(?:execute .* run )?function ([^:]+):([^\s]+)$/);
+            if (emptyCallMatch) {
+                const targetFn = emptyCallMatch[2];
+                if (emptyFunctions.has(targetFn)) {
+                    // Skip calls to empty functions entirely
+                    continue;
+                }
+            }
+            // Rewrite calls to trivial wrapper functions
+            const rewritten = cmd.cmd.replace(/function ([^:]+):([^\s]+)/g, (match, ns, fnPath) => {
+                const target = trivialMap.get(fnPath);
+                return target ? `function ${ns}:${target}` : match;
+            });
+            rewrittenCmds.push({ ...cmd, cmd: rewritten });
+        }
+        result.push({ name: fn.name, commands: rewrittenCmds });
+    }
+    return {
+        functions: result,
+        stats: { inlinedTrivialFunctions: totalRemoved }
+    };
+}
 function optimizeCommandFunctions(functions) {
     const initial = cloneFunctions(functions);
     const stats = createEmptyOptimizationStats();
     stats.totalCommandsBefore = initial.reduce((sum, fn) => sum + fn.commands.length, 0);
-    const licm = applyLICM(initial);
+    // First pass: inline trivial functions
+    const inlined = inlineTrivialFunctions(initial);
+    mergeOptimizationStats(stats, inlined.stats);
+    const licm = applyLICM(inlined.functions);
     mergeOptimizationStats(stats, licm.stats);
     const cse = applyCSE(licm.functions);
     mergeOptimizationStats(stats, cse.stats);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.12",
+  "version": "1.2.14",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/fixtures/macro-test.mcrs

@@ -0,0 +1,35 @@
+// MC 1.20.2+ macro function test
+// Tests that functions using parameters in coordinate/type positions
+// generate macro syntax ($-prefixed commands with $(param) substitution)
+//
+// Compilation: redscript compile macro-test.mcrs -o output/ -n test
+
+// Basic macro function: parameters used as summon coordinates
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+
+// Macro function: particle effect at coordinates
+fn show_particle(x: int, y: int, z: int) {
+    particle("minecraft:flame", x, y, z);
+}
+
+// Macro function: setblock at variable position
+fn place_block(x: int, y: int, z: int) {
+    setblock(x, y, z, "minecraft:stone");
+}
+
+// Non-macro function: all args are compile-time constants in the body
+fn summon_fixed() {
+    summon("minecraft:zombie", 100, 64, 200);
+}
+
+// Caller with constant args (calls macro function with inline NBT data)
+fn call_with_constants() {
+    spawn_zombie(100, 64, 200);
+}
+
+// Caller with variable args (calls macro function via 'with storage rs:macro_args')
+fn call_with_vars(px: int, pz: int) {
+    spawn_zombie(px, 64, pz);
+}