redscript-mc 1.2.13 → 1.2.15

package/dist/lowering/index.js

@@ -45,6 +45,14 @@ 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.
+// ---------------------------------------------------------------------------
+// All builtins support macro parameters - any arg that's a function param
+// will automatically use MC 1.20.2+ macro syntax when needed
+// ---------------------------------------------------------------------------
 // Builtin Functions
 // ---------------------------------------------------------------------------
 const BUILTINS = {
@@ -213,12 +221,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' && BUILTINS[expr.fn] !== undefined) {
+            // 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 +487,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 +594,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 +1788,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 +1928,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 +1947,8 @@ class Lowering {
             this.blockPosVars = savedBlockPosVars;
             this.stringValues = savedStringValues;
             this.varTypes = savedVarTypes;
+            this.currentFnParamNames = savedCurrentFnParamNames;
+            this.currentFnMacroParams = savedCurrentFnMacroParams;
         }
     }
     lowerBuiltinCall(name, args, callSpan) {
@@ -1967,26 +2182,30 @@ 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 };
         }
-        // Convert args to strings for builtin (use SNBT for struct/array literals)
-        const strArgs = args.map(arg => arg.kind === 'struct_lit' || arg.kind === 'array_lit'
-            ? this.exprToSnbt(arg)
-            : this.exprToString(arg));
-        const cmd = BUILTINS[name](strArgs);
+        // All builtins support macro params - check if any arg is a param needing macro treatment
+        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(cmd);
+            this.builder.emitRaw(hasMacroArg ? `$${cmd}` : cmd);
         }
         return { kind: 'const', value: 0 };
     }
@@ -2488,6 +2707,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.13",
+  "version": "1.2.15",
   "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);
+}