redscript-mc 1.2.16 → 1.2.18

package/src/__tests__/compile-all.test.ts

@@ -0,0 +1,60 @@
+/**
+ * Compile-all smoke test
+ *
+ * Finds every .mcrs file in the repo (excluding declaration files and node_modules)
+ * and verifies that each one compiles without throwing an error.
+ *
+ * This catches regressions where a language change breaks existing source files.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import { compile } from '../compile'
+
+const REPO_ROOT = path.resolve(__dirname, '../../')
+
+/** Patterns to skip */
+const SKIP_GLOBS = [
+  'node_modules',
+  '.git',
+  'builtins.d.mcrs',   // declaration-only file, not valid source
+  'editors/',          // copy of builtins.d.mcrs
+]
+
+function shouldSkip(filePath: string): boolean {
+  const rel = path.relative(REPO_ROOT, filePath)
+  return SKIP_GLOBS.some(pat => rel.includes(pat))
+}
+
+function findMcrsFiles(dir: string): string[] {
+  const results: string[] = []
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name)
+    if (shouldSkip(fullPath)) continue
+    if (entry.isDirectory()) {
+      results.push(...findMcrsFiles(fullPath))
+    } else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
+      results.push(fullPath)
+    }
+  }
+  return results
+}
+
+const mcrsFiles = findMcrsFiles(REPO_ROOT)
+
+describe('compile-all: every .mcrs file should compile without errors', () => {
+  test('found at least one .mcrs file', () => {
+    expect(mcrsFiles.length).toBeGreaterThan(0)
+  })
+
+  for (const filePath of mcrsFiles) {
+    const label = path.relative(REPO_ROOT, filePath)
+    test(label, () => {
+      const source = fs.readFileSync(filePath, 'utf8')
+      // Should not throw
+      expect(() => {
+        compile(source, { namespace: 'smoke_test', optimize: false })
+      }).not.toThrow()
+    })
+  }
+})

package/src/builtins/metadata.ts

@@ -1029,16 +1029,13 @@ export const BUILTIN_METADATA: Record<string, BuiltinDef> = {
 export function builtinToDeclaration(def: BuiltinDef): string {
   const lines: string[] = []
 
-  // Doc comments
+  // Doc comments (English only)
   lines.push(`/// ${def.doc}`)
-  if (def.docZh) {
-    lines.push(`/// ${def.docZh}`)
-  }
 
   // Param docs
   for (const p of def.params) {
-    const opt = p.required ? '' : '?'
-    lines.push(`/// @param ${p.name}${opt} ${p.doc}`)
+    const optTag = p.required ? '' : ' (optional)'
+    lines.push(`/// @param ${p.name} ${p.doc}${optTag}`)
   }
 
   // Returns
@@ -1051,13 +1048,9 @@ export function builtinToDeclaration(def: BuiltinDef): string {
     lines.push(`/// @example ${ex.split('\n')[0]}`)
   }
 
-  // Signature
+  // Signature - use default value syntax instead of ? for optional params
   const paramStrs = def.params.map(p => {
-    const opt = p.required ? '' : '?'
     let type = p.type
-    // Map to .d.mcrs types
-    if (type === 'selector') type = 'selector'
-    if (type === 'BlockPos') type = 'BlockPos'
     if (type === 'effect') type = 'string'
     if (type === 'sound') type = 'string'
     if (type === 'block') type = 'string'
@@ -1065,8 +1058,10 @@ export function builtinToDeclaration(def: BuiltinDef): string {
     if (type === 'entity') type = 'string'
     if (type === 'dimension') type = 'string'
     if (type === 'nbt') type = 'string'
-    if (type === 'coord') type = 'coord'
-    return `${p.name}${opt}: ${type}`
+    if (!p.required && p.default !== undefined) {
+      return `${p.name}: ${type} = ${p.default}`
+    }
+    return `${p.name}: ${type}`
   })
 
   const retType = def.returns

package/src/lexer/index.ts

@@ -16,7 +16,7 @@ export type TokenKind =
   // Keywords
   | 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match'
   | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace'
-  | 'execute' | 'run' | 'unless'
+  | 'execute' | 'run' | 'unless' | 'declare'
   // Types
   | 'int' | 'bool' | 'float' | 'string' | 'void'
   | 'BlockPos'
@@ -89,6 +89,7 @@ const KEYWORDS: Record<string, TokenKind> = {
   execute: 'execute',
   run: 'run',
   unless: 'unless',
+  declare: 'declare',
   int: 'int',
   bool: 'bool',
   float: 'float',
@@ -298,6 +299,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,38 @@ export class Lowering {
     if (macroParam) {
       return { str: `$(${macroParam})`, macroParam }
     }
+    // Handle ~ident / ^ident syntax — relative/local coord with a VARIABLE offset.
+    //
+    // WHY macros are required here:
+    //   Minecraft's ~N and ^N coordinate syntax requires N to be a compile-time
+    //   literal number. There is no command that accepts a scoreboard value as a
+    //   relative offset. Therefore `~height` (where height is a runtime int) can
+    //   only be expressed at the MC level via the 1.20.2+ function macro system,
+    //   which substitutes $(height) into the command text at call time.
+    //
+    //   Contrast with absolute coords: `tp(target, x, y, z)` where x/y/z are
+    //   plain ints — those become $(x) etc. as literal replacements, same mechanism,
+    //   but the distinction matters to callers: ~$(height) means "relative by height
+    //   blocks from current pos", not "teleport to absolute scoreboard value".
+    //
+    //   Example:
+    //     fn launch_up(target: selector, height: int) {
+    //       tp(target, ~0, ~height, ~0);   // "~height" parsed as rel_coord
+    //     }
+    //   Emits:  $tp $(target) ~0 ~$(height) ~0
+    //   Called: function ns:launch_up with storage rs:macro_args
+    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) }
     }

package/src/parser/index.ts

@@ -180,6 +180,10 @@ export class Parser {
         enums.push(this.parseEnumDecl())
       } else if (this.check('const')) {
         consts.push(this.parseConstDecl())
+      } else if (this.check('declare')) {
+        // Declaration-only stub (e.g. from builtins.d.mcrs) — parse and discard
+        this.advance() // consume 'declare'
+        this.parseDeclareStub()
       } else {
         declarations.push(this.parseFnDecl())
       }
@@ -260,12 +264,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 {
@@ -302,6 +315,25 @@ export class Parser {
     return this.withLoc({ name, params, returnType, decorators, body }, fnToken)
   }
 
+  /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
+  private parseDeclareStub(): void {
+    this.expect('fn')
+    this.expect('ident') // name
+    this.expect('(')
+    // consume params until ')'
+    let depth = 1
+    while (!this.check('eof') && depth > 0) {
+      const t = this.advance()
+      if (t.kind === '(') depth++
+      else if (t.kind === ')') depth--
+    }
+    // optional return type annotation `: type` or `-> type`
+    if (this.match(':') || this.match('->')) {
+      this.parseType()
+    }
+    this.match(';') // consume trailing semicolon
+  }
+
   private parseDecorators(): Decorator[] {
     const decorators: Decorator[] = []