redscript-mc 1.2.14 → 1.2.16

package/src/cli.ts

@@ -14,6 +14,7 @@ import { generateCommandBlocks } from './codegen/cmdblock'
 import { compileToStructure } from './codegen/structure'
 import { formatError } from './diagnostics'
 import { startRepl } from './repl'
+import { generateDts } from './builtins/metadata'
 import type { OptimizationStats } from './optimizer/commands'
 import * as fs from 'fs'
 import * as path from 'path'
@@ -30,16 +31,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
@@ -441,6 +444,14 @@ async function main(): Promise<void> {
       break
     }
 
+    case 'generate-dts': {
+      const output = parsed.output ?? 'builtins.d.mcrs'
+      const dtsContent = generateDts()
+      fs.writeFileSync(output, dtsContent, 'utf-8')
+      console.log(`Generated ${output}`)
+      break
+    }
+
     case 'repl':
       await startRepl(parsed.namespace ?? 'repl')
       break

package/src/lowering/index.ts

@@ -25,10 +25,8 @@ import { EVENT_TYPES, getEventParamSpecs, isEventTypeName } from '../events/type
 // 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
@@ -335,7 +333,7 @@ export class Lowering {
   }
 
   private preScanExpr(expr: Expr, paramNames: Set<string>, macroParams: Set<string>): void {
-    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)) {
@@ -787,6 +785,7 @@ export class Lowering {
         this.lowerExecuteStmt(stmt)
         break
       case 'raw':
+        this.checkRawCommandInterpolation(stmt.cmd, stmt.span)
         this.builder.emitRaw(stmt.cmd)
         break
     }
@@ -2528,30 +2527,16 @@ export 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 }
@@ -3269,6 +3254,44 @@ export 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.
+   */
+  private checkRawCommandInterpolation(cmd: string, span?: Span): void {
+    const interpRe = /\$\{([^}]+)\}/g
+    let match: RegExpExecArray | null
+    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 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
+        )
+      }
+    }
+  }
+
   private resolveInstanceMethod(expr: Extract<Expr, { kind: 'call' }>): { fn: FnDecl; loweredName: string } | null {
     const receiver = expr.args[0]
     if (!receiver) {