redscript-mc 1.2.15 → 1.2.17

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

@@ -298,6 +298,15 @@ export 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/src/lowering/index.ts

@@ -371,6 +371,13 @@ export class Lowering {
     return expr.name
   }
 
+  private tryGetMacroParamByName(name: string): string | null {
+    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.
@@ -380,6 +387,19 @@ export 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) }
     }
@@ -785,6 +805,7 @@ export class Lowering {
         this.lowerExecuteStmt(stmt)
         break
       case 'raw':
+        this.checkRawCommandInterpolation(stmt.cmd, stmt.span)
         this.builder.emitRaw(stmt.cmd)
         break
     }
@@ -3253,6 +3274,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) {

package/src/parser/index.ts

@@ -260,12 +260,21 @@ export class Parser {
   private parseConstDecl(): ConstDecl {
     const constToken = this.expect('const')
     const name = this.expect('ident').value
-    this.expect(':')
-    const type = this.parseType()
+    let type: TypeNode | undefined
+    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: TypeNode = 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)
   }
 
   private parseGlobalDecl(mutable: boolean): GlobalDecl {