redscript-mc 1.2.14 → 1.2.16

package/dist/cli.js

@@ -48,6 +48,7 @@ const cmdblock_1 = require("./codegen/cmdblock");
 const structure_1 = require("./codegen/structure");
 const diagnostics_1 = require("./diagnostics");
 const repl_1 = require("./repl");
+const metadata_1 = require("./builtins/metadata");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 // Parse command line arguments
@@ -61,16 +62,18 @@ Usage:
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
   redscript fmt <file.mcrs> [file2.mcrs ...]
+  redscript generate-dts [-o <file>]
   redscript repl
   redscript version
 
 Commands:
-  compile   Compile a RedScript file to a Minecraft datapack
-  watch     Watch a directory for .mcrs file changes, recompile, and hot reload
-  check     Check a RedScript file for errors without generating output
-  fmt       Auto-format RedScript source files
-  repl      Start an interactive RedScript REPL
-  version   Print the RedScript version
+  compile       Compile a RedScript file to a Minecraft datapack
+  watch         Watch a directory for .mcrs file changes, recompile, and hot reload
+  check         Check a RedScript file for errors without generating output
+  fmt           Auto-format RedScript source files
+  generate-dts  Generate builtin function declaration file (builtins.d.mcrs)
+  repl          Start an interactive RedScript REPL
+  version       Print the RedScript version
 
 Options:
   -o, --output <path>    Output directory or file path, depending on target
@@ -414,6 +417,13 @@ async function main() {
             }
             break;
         }
+        case 'generate-dts': {
+            const output = parsed.output ?? 'builtins.d.mcrs';
+            const dtsContent = (0, metadata_1.generateDts)();
+            fs.writeFileSync(output, dtsContent, 'utf-8');
+            console.log(`Generated ${output}`);
+            break;
+        }
         case 'repl':
             await (0, repl_1.startRepl)(parsed.namespace ?? 'repl');
             break;

package/dist/lowering/index.d.ts

@@ -151,6 +151,17 @@ export declare class Lowering {
     private getArrayStorageName;
     private inferLambdaReturnType;
     private inferExprType;
+    /**
+     * Checks a raw() command string for `${...}` interpolation containing runtime variables.
+     * - If the interpolated expression is a numeric literal → OK (MC macro syntax).
+     * - If the interpolated name is a compile-time constant (in constValues) → OK.
+     * - If the interpolated name is a known runtime variable (in varMap) → DiagnosticError.
+     * - Unknown names → OK (could be MC macro params or external constants).
+     *
+     * This catches the common mistake of writing raw("say ${score}") expecting interpolation,
+     * which would silently emit a literal `${score}` in the MC command.
+     */
+    private checkRawCommandInterpolation;
     private resolveInstanceMethod;
     private normalizeType;
     private readArrayElement;

package/dist/lowering/index.js

@@ -50,10 +50,8 @@ const types_1 = require("../events/types");
 // 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',
-]);
+// 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
 // ---------------------------------------------------------------------------
@@ -313,7 +311,7 @@ class Lowering {
         }
     }
     preScanExpr(expr, paramNames, macroParams) {
-        if (expr.kind === 'call' && MACRO_AWARE_BUILTINS.has(expr.fn)) {
+        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)) {
@@ -706,6 +704,7 @@ class Lowering {
                 this.lowerExecuteStmt(stmt);
                 break;
             case 'raw':
+                this.checkRawCommandInterpolation(stmt.cmd, stmt.span);
                 this.builder.emitRaw(stmt.cmd);
                 break;
         }
@@ -2197,28 +2196,17 @@ class Lowering {
             }
             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 };
+        // 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); });
         }
-        // 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);
+        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 };
     }
@@ -2843,6 +2831,39 @@ class Lowering {
         }
         return undefined;
     }
+    /**
+     * Checks a raw() command string for `${...}` interpolation containing runtime variables.
+     * - If the interpolated expression is a numeric literal → OK (MC macro syntax).
+     * - If the interpolated name is a compile-time constant (in constValues) → OK.
+     * - If the interpolated name is a known runtime variable (in varMap) → DiagnosticError.
+     * - Unknown names → OK (could be MC macro params or external constants).
+     *
+     * This catches the common mistake of writing raw("say ${score}") expecting interpolation,
+     * which would silently emit a literal `${score}` in the MC command.
+     */
+    checkRawCommandInterpolation(cmd, span) {
+        const interpRe = /\$\{([^}]+)\}/g;
+        let match;
+        while ((match = interpRe.exec(cmd)) !== null) {
+            const name = match[1].trim();
+            // Numeric/boolean literals are fine (intentional MC macro syntax)
+            if (/^\d+(\.\d+)?$/.test(name) || name === 'true' || name === 'false') {
+                continue;
+            }
+            // Compile-time constants are fine
+            if (this.constValues.has(name)) {
+                continue;
+            }
+            // Only error if it's a known runtime variable (in varMap or function params)
+            // Unknown identifiers are left alone (could be MC macro params the user intends)
+            if (this.varMap.has(name) || this.currentFnParamNames.has(name)) {
+                const loc = span ?? { line: 1, col: 1 };
+                throw new diagnostics_1.DiagnosticError('LoweringError', `raw() command contains runtime variable interpolation '\${${name}}'. ` +
+                    `Variables cannot be interpolated into raw commands at compile time. ` +
+                    `Use f-string messages (say/tell/announce) or MC macro syntax '$(${name})' for MC 1.20.2+ commands.`, loc);
+            }
+        }
+    }
     resolveInstanceMethod(expr) {
         const receiver = expr.args[0];
         if (!receiver) {