redscript-mc 1.2.15 → 1.2.17

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/lexer/index.js

@@ -222,6 +222,15 @@ class Lexer {
                     value += this.advance();
                 }
             }
+            // Check for ident (e.g. ~height → macro variable offset)
+            if (/[a-zA-Z_]/.test(this.peek())) {
+                let ident = '';
+                while (/[a-zA-Z0-9_]/.test(this.peek())) {
+                    ident += this.advance();
+                }
+                // Store as rel_coord with embedded ident: ~height
+                value += ident;
+            }
             this.addToken('rel_coord', value, startLine, startCol);
             return;
         }

package/dist/lowering/index.d.ts

@@ -60,6 +60,7 @@ export declare class Lowering {
      * used in a literal position), returns the param name; otherwise null.
      */
     private tryGetMacroParam;
+    private tryGetMacroParamByName;
     /**
      * Converts an expression to a string for use as a builtin arg.
      * If the expression is a macro param, returns `$(name)` and sets macroParam.
@@ -151,6 +152,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

@@ -354,6 +354,15 @@ class Lowering {
             return null;
         return expr.name;
     }
+    tryGetMacroParamByName(name) {
+        if (!this.currentFnParamNames.has(name))
+            return null;
+        if (this.constValues.has(name))
+            return null;
+        if (this.stringValues.has(name))
+            return null;
+        return 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.
@@ -363,6 +372,19 @@ class Lowering {
         if (macroParam) {
             return { str: `$(${macroParam})`, macroParam };
         }
+        // Handle ~ident (e.g. ~height) - relative coord with variable offset
+        if (expr.kind === 'rel_coord' || expr.kind === 'local_coord') {
+            const val = expr.value; // e.g. "~height" or "^depth"
+            const prefix = val[0]; // ~ or ^
+            const rest = val.slice(1);
+            // If rest is an identifier (not a number), treat as macro param
+            if (rest && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(rest)) {
+                const paramName = this.tryGetMacroParamByName(rest);
+                if (paramName) {
+                    return { str: `${prefix}$(${paramName})`, macroParam: paramName };
+                }
+            }
+        }
         if (expr.kind === 'struct_lit' || expr.kind === 'array_lit') {
             return { str: this.exprToSnbt(expr) };
         }
@@ -704,6 +726,7 @@ class Lowering {
                 this.lowerExecuteStmt(stmt);
                 break;
             case 'raw':
+                this.checkRawCommandInterpolation(stmt.cmd, stmt.span);
                 this.builder.emitRaw(stmt.cmd);
                 break;
         }
@@ -2830,6 +2853,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) {

package/dist/parser/index.js

@@ -213,12 +213,19 @@ class Parser {
     parseConstDecl() {
         const constToken = this.expect('const');
         const name = this.expect('ident').value;
-        this.expect(':');
-        const type = this.parseType();
+        let type;
+        if (this.match(':')) {
+            type = this.parseType();
+        }
         this.expect('=');
         const value = this.parseLiteralExpr();
         this.match(';');
-        return this.withLoc({ name, type, value }, constToken);
+        // Infer type from value if not provided
+        const inferredType = type ?? (value.kind === 'str_lit' ? { kind: 'named', name: 'string' } :
+            value.kind === 'bool_lit' ? { kind: 'named', name: 'bool' } :
+                value.kind === 'float_lit' ? { kind: 'named', name: 'float' } :
+                    { kind: 'named', name: 'int' });
+        return this.withLoc({ name, type: inferredType, value }, constToken);
     }
     parseGlobalDecl(mutable) {
         const token = this.advance(); // consume 'let'