redscript-mc 2.6.2 → 3.0.0

package/src/mir/macro.ts

@@ -21,6 +21,19 @@ export const BUILTIN_SET = new Set([
   'summon', 'particle', 'playsound', 'clear', 'weather',
   'time_set', 'time_add', 'gamerule', 'tag_add', 'tag_remove',
   'kick', 'setblock', 'fill', 'clone', 'difficulty', 'xp_add', 'xp_set',
+  // Entity movement / teleport
+  'tp', 'tp_to',
+  // Scoreboard management
+  'scoreboard_add_objective', 'scoreboard_remove_objective',
+  'scoreboard_display', 'scoreboard_hide',
+  // Team management
+  'team_add', 'team_remove', 'team_join', 'team_leave', 'team_option',
+  // Bossbar management
+  'bossbar_add', 'bossbar_remove', 'bossbar_set_value', 'bossbar_get_value',
+  'bossbar_set_max', 'bossbar_set_color', 'bossbar_set_style',
+  'bossbar_set_visible', 'bossbar_set_players',
+  // Data / NBT
+  'data_get', 'data_merge',
 ])
 
 // ---------------------------------------------------------------------------
@@ -47,7 +60,14 @@ export function detectMacroFunctions(hir: HIRModule): Map<string, MacroFunctionI
     if (macroParams.size > 0) {
       const paramTypes = new Map<string, string>()
       for (const p of fn.params) {
-        const typeName = p.type?.kind === 'named' ? (p.type as any).name : 'int'
+        let typeName: string
+        if (p.type?.kind === 'named') {
+          typeName = (p.type as any).name
+        } else if (p.type?.kind === 'selector' || p.type?.kind === 'entity') {
+          typeName = 'selector'
+        } else {
+          typeName = 'int'
+        }
         paramTypes.set(p.name, typeName)
       }
       result.set(fn.name, { macroParams, paramTypes })
@@ -62,7 +82,14 @@ export function detectMacroFunctions(hir: HIRModule): Map<string, MacroFunctionI
       if (macroParams.size > 0) {
         const paramTypes = new Map<string, string>()
         for (const p of m.params) {
-          const typeName = p.type?.kind === 'named' ? (p.type as any).name : 'int'
+          let typeName: string
+          if (p.type?.kind === 'named') {
+            typeName = (p.type as any).name
+          } else if (p.type?.kind === 'selector' || p.type?.kind === 'entity') {
+            typeName = 'selector'
+          } else {
+            typeName = 'int'
+          }
           paramTypes.set(p.name, typeName)
         }
         result.set(`${ib.typeName}::${m.name}`, { macroParams, paramTypes })
@@ -102,6 +129,7 @@ function scanStmt(stmt: HIRStmt, paramNames: Set<string>, macroParams: Set<strin
       for (const arm of stmt.arms) scanBlock(arm.body, paramNames, macroParams)
       break
     case 'execute': scanBlock(stmt.body, paramNames, macroParams); break
+    case 'labeled_loop': scanStmt(stmt.body, paramNames, macroParams); break
     case 'raw': break
   }
 }

package/src/mir/types.ts

@@ -66,10 +66,12 @@ export type MIRInstr = MIRInstrBase & (
   | { kind: 'mul'; dst: Temp; a: Operand; b: Operand }
   | { kind: 'div'; dst: Temp; a: Operand; b: Operand }
   | { kind: 'mod'; dst: Temp; a: Operand; b: Operand }
+  | { kind: 'pow'; dst: Temp; a: Operand; b: Operand }
   | { kind: 'neg'; dst: Temp; src: Operand }
 
   // ── Comparison (result is 0 or 1) ────────────────────────────────────────
   | { kind: 'cmp'; dst: Temp; op: CmpOp; a: Operand; b: Operand }
+  | { kind: 'string_match'; dst: Temp; ns: string; path: string; value: string }
 
   // ── Boolean logic ────────────────────────────────────────────────────────
   | { kind: 'and'; dst: Temp; a: Operand; b: Operand }
@@ -115,10 +117,21 @@ export interface MIRFunction {
   blocks: MIRBlock[]
   entry: BlockId         // entry block id (always 'entry')
   isMacro: boolean       // true if any param is a macro param
+  sourceLoc?: SourceLoc
+  sourceSnippet?: string
 }
 
 export interface MIRModule {
   functions: MIRFunction[]
   namespace: string
   objective: string      // scoreboard objective (default: __<namespace>)
+  /** Set of fully-qualified function names marked @inline. */
+  inlineFunctions?: Set<string>
+  /** Set of fully-qualified function names marked @no-inline. */
+  noInlineFunctions?: Set<string>
+  /**
+   * Set of function names that were auto-inlined and whose definitions should
+   * still be emitted as separate .mcfunction files (so library callers work).
+   */
+  keepInOutput?: Set<string>
 }

package/src/mir/verify.ts

@@ -106,6 +106,11 @@ function verifyFunction(fn: MIRFunction): VerifyError[] {
   // Collect all defined temps: params + all dst fields in instructions
   const allDefs = new Set<Temp>()
   for (const p of fn.params) allDefs.add(p.name)
+  // __rf_* temps are "return frame" slots set by the callee at runtime.
+  // Pre-seed them so the verifier doesn't false-positive on caller reads.
+  for (let i = 0; i < 16; i++) allDefs.add(`__rf_${i}`)
+  allDefs.add('__rf_has')
+  allDefs.add('__rf_val')
   for (const block of fn.blocks) {
     for (const instr of block.instrs) {
       const dst = getDst(instr)
@@ -159,9 +164,10 @@ function getDst(instr: MIRInstr): Temp | null {
   switch (instr.kind) {
     case 'const':
     case 'copy':
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
     case 'neg':
     case 'cmp':
+    case 'string_match':
     case 'and': case 'or': case 'not':
     case 'nbt_read':
     case 'nbt_read_dynamic':
@@ -189,11 +195,13 @@ function getUsedTemps(instr: MIRInstr): Temp[] {
     case 'not':
       temps.push(...getOperandTemps(instr.src))
       break
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
     case 'cmp':
     case 'and': case 'or':
       temps.push(...getOperandTemps(instr.a), ...getOperandTemps(instr.b))
       break
+    case 'string_match':
+      break
     case 'nbt_read':
     case 'nbt_list_len':
       break

package/src/optimizer/auto-inline.ts

@@ -0,0 +1,86 @@
+import type { MIRFunction, MIRModule } from '../mir/types'
+import { inlinePass } from './inline'
+
+const SMALL_FUNCTION_INSTR_LIMIT = 5
+
+export function autoInlineSmallFunctions(mod: MIRModule): MIRModule {
+  const recursiveFns = findRecursiveFunctions(mod.functions)
+  const noInlineFns = mod.noInlineFunctions ?? new Set<string>()
+  const autoInlineFns = new Set<string>()
+
+  for (const fn of mod.functions) {
+    if (fn.isMacro) continue
+    if (noInlineFns.has(fn.name)) continue
+    if (recursiveFns.has(fn.name)) continue
+    if (countFunctionInstrs(fn) > SMALL_FUNCTION_INSTR_LIMIT) continue
+    // Don't auto-inline functions with raw() calls — these reference
+    // MC calling-convention registers ($p0, etc.) that become invalid when inlined.
+    if (containsRawCall(fn)) continue
+    autoInlineFns.add(fn.name)
+  }
+
+  const inlineFunctions = new Set(mod.inlineFunctions ?? [])
+  for (const fnName of autoInlineFns) inlineFunctions.add(fnName)
+
+  // Track auto-inlined functions so compile pipeline can keep their output files
+  const keepInOutput = new Set(mod.keepInOutput ?? [])
+  for (const fnName of autoInlineFns) keepInOutput.add(fnName)
+
+  return inlinePass({ ...mod, inlineFunctions, keepInOutput })
+}
+
+function containsRawCall(fn: MIRFunction): boolean {
+  for (const block of fn.blocks) {
+    for (const instr of block.instrs) {
+      if (instr.kind === 'call' && instr.fn.startsWith('__raw:')) return true
+    }
+  }
+  return false
+}
+
+function countFunctionInstrs(fn: MIRFunction): number {
+  let count = 0
+  for (const block of fn.blocks) {
+    count += block.instrs.length + 1
+  }
+  return count
+}
+
+function findRecursiveFunctions(functions: MIRFunction[]): Set<string> {
+  const fnNames = new Set(functions.map(fn => fn.name))
+  const edges = new Map<string, Set<string>>()
+
+  for (const fn of functions) {
+    const callees = new Set<string>()
+    for (const block of fn.blocks) {
+      for (const instr of block.instrs) {
+        if ((instr.kind === 'call' || instr.kind === 'call_macro') && fnNames.has(instr.fn)) {
+          callees.add(instr.fn)
+        }
+      }
+    }
+    edges.set(fn.name, callees)
+  }
+
+  const recursive = new Set<string>()
+
+  for (const fn of functions) {
+    const seen = new Set<string>()
+    const stack = [...(edges.get(fn.name) ?? [])]
+
+    while (stack.length > 0) {
+      const current = stack.pop()!
+      if (current === fn.name) {
+        recursive.add(fn.name)
+        break
+      }
+      if (seen.has(current)) continue
+      seen.add(current)
+      for (const next of edges.get(current) ?? []) {
+        stack.push(next)
+      }
+    }
+  }
+
+  return recursive
+}

package/src/optimizer/copy_prop.ts

@@ -70,7 +70,7 @@ function rewriteUses(instr: MIRInstr, copies: Map<Temp, Operand>): MIRInstr {
     case 'neg':
     case 'not':
       return { ...instr, src: resolve(instr.src, copies) }
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
     case 'and': case 'or':
       return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) }
     case 'cmp':
@@ -99,7 +99,7 @@ function rewriteUses(instr: MIRInstr, copies: Map<Temp, Operand>): MIRInstr {
 function getDst(instr: MIRInstr): Temp | null {
   switch (instr.kind) {
     case 'const': case 'copy':
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
     case 'neg': case 'cmp':
     case 'and': case 'or': case 'not':
     case 'nbt_read':

package/src/optimizer/coroutine.ts

@@ -988,7 +988,7 @@ function rewriteInstr(instr: MIRInstr, promoted: Map<Temp, Temp>): MIRInstr {
       return { ...instr, dst: rTemp(instr.dst) }
     case 'copy':
       return { ...instr, dst: rTemp(instr.dst), src: rOp(instr.src) }
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
       return { ...instr, dst: rTemp(instr.dst), a: rOp(instr.a), b: rOp(instr.b) }
     case 'neg':
       return { ...instr, dst: rTemp(instr.dst), src: rOp(instr.src) }
@@ -1057,7 +1057,7 @@ function getSuccessors(term: MIRInstr): BlockId[] {
 function getDst(instr: MIRInstr): Temp | null {
   switch (instr.kind) {
     case 'const': case 'copy':
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
     case 'neg': case 'cmp':
     case 'and': case 'or': case 'not':
     case 'nbt_read':
@@ -1077,7 +1077,7 @@ function getUsedTemps(instr: MIRInstr): Temp[] {
   switch (instr.kind) {
     case 'copy': case 'neg': case 'not':
       addOp(instr.src); break
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
     case 'cmp': case 'and': case 'or':
       addOp(instr.a); addOp(instr.b); break
     case 'nbt_write':

package/src/optimizer/cse.ts

@@ -0,0 +1,205 @@
+/**
+ * Common Subexpression Elimination (CSE) — MIR optimization pass.
+ *
+ * Performs local (intra-block) CSE: within each BasicBlock, if a pure
+ * computation has already been computed and its operands haven't been
+ * overwritten since, reuse the previous result via a `copy` instead of
+ * recomputing.
+ *
+ * Pure instructions considered:
+ *   add, sub, mul, div, mod, neg, cmp, and, or, not
+ *
+ * Side-effect instructions that invalidate expressions when their
+ * destination (or any operand) is overwritten:
+ *   score_write, nbt_write, nbt_write_dynamic, call, call_macro,
+ *   call_context, and any instruction that redefines a temp.
+ *
+ * Global (cross-block) CSE is not performed — only per-block.
+ */
+
+import type { MIRFunction, MIRBlock, MIRInstr, Operand, Temp } from '../mir/types'
+
+// ---------------------------------------------------------------------------
+// Expression key helpers
+// ---------------------------------------------------------------------------
+
+function operandKey(op: Operand): string {
+  return op.kind === 'const' ? `c:${op.value}` : `t:${op.name}`
+}
+
+/** Commutative ops — operand order doesn't matter. */
+const COMMUTATIVE = new Set(['add', 'mul', 'and', 'or'])
+
+function exprKey(instr: MIRInstr): string | null {
+  switch (instr.kind) {
+    case 'add':
+    case 'sub':
+    case 'mul':
+    case 'div':
+    case 'mod':
+    case 'pow':
+    case 'and':
+    case 'or': {
+      const ka = operandKey(instr.a)
+      const kb = operandKey(instr.b)
+      const [l, r] = COMMUTATIVE.has(instr.kind) && ka > kb ? [kb, ka] : [ka, kb]
+      return `${instr.kind}:${l}:${r}`
+    }
+    case 'neg':
+    case 'not':
+      return `${instr.kind}:${operandKey(instr.src)}`
+    case 'cmp': {
+      const ka = operandKey(instr.a)
+      const kb = operandKey(instr.b)
+      return `cmp:${instr.op}:${ka}:${kb}`
+    }
+    default:
+      return null
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Temp defined by an instruction
+// ---------------------------------------------------------------------------
+
+function getDst(instr: MIRInstr): Temp | null {
+  switch (instr.kind) {
+    case 'const': case 'copy': case 'add': case 'sub': case 'mul':
+    case 'div': case 'mod': case 'pow': case 'neg': case 'not': case 'and':
+    case 'or': case 'cmp': case 'string_match': case 'nbt_read':
+    case 'nbt_read_dynamic': case 'nbt_list_len': case 'score_read':
+      return instr.dst
+    case 'call': case 'call_macro':
+      return instr.dst
+    default:
+      return null
+  }
+}
+
+/** Temps used as operands in an instruction (for invalidation). */
+function getUsedTemps(instr: MIRInstr): Temp[] {
+  const temps: Temp[] = []
+  const add = (op: Operand) => { if (op.kind === 'temp') temps.push(op.name) }
+  switch (instr.kind) {
+    case 'copy': add(instr.src); break
+    case 'neg': case 'not': add(instr.src); break
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
+    case 'and': case 'or': add(instr.a); add(instr.b); break
+    case 'cmp': add(instr.a); add(instr.b); break
+    case 'nbt_write': add(instr.src); break
+    case 'nbt_write_dynamic': add(instr.indexSrc); add(instr.valueSrc); break
+    case 'nbt_read_dynamic': add(instr.indexSrc); break
+    case 'score_write': add(instr.src); break
+    case 'call': instr.args.forEach(add); break
+    case 'call_macro': instr.args.forEach(a => add(a.value)); break
+    case 'branch': add(instr.cond); break
+    case 'return': if (instr.value) add(instr.value); break
+    case 'jump': break
+  }
+  return temps
+}
+
+// ---------------------------------------------------------------------------
+// Block-level CSE
+// ---------------------------------------------------------------------------
+
+function cseBlock(block: MIRBlock): MIRBlock {
+  // Map: expression key → temp holding the already-computed result
+  const available = new Map<string, Temp>()
+  // Map: temp → set of expression keys that depend on it (for invalidation)
+  const tempDeps = new Map<Temp, Set<string>>()
+
+  function recordDep(key: string, deps: Temp[]) {
+    for (const dep of deps) {
+      if (!tempDeps.has(dep)) tempDeps.set(dep, new Set())
+      tempDeps.get(dep)!.add(key)
+    }
+  }
+
+  function invalidate(temp: Temp) {
+    // Remove all expressions that depend on this temp
+    const keys = tempDeps.get(temp)
+    if (keys) {
+      for (const key of keys) {
+        available.delete(key)
+      }
+      tempDeps.delete(temp)
+    }
+    // Also remove any expression whose result was stored in this temp
+    for (const [key, resultTemp] of available) {
+      if (resultTemp === temp) {
+        available.delete(key)
+      }
+    }
+  }
+
+  const instrs: MIRInstr[] = []
+
+  for (const instr of block.instrs) {
+    const key = exprKey(instr)
+
+    if (key !== null) {
+      const existing = available.get(key)
+      if (existing !== undefined) {
+        const dst = getDst(instr)!
+        // Don't CSE self-modifying instructions (dst is one of the source temps).
+        // e.g. t5 = t5 + 1: each occurrence uses a different value of t5.
+        const selfModifying = getUsedTemps(instr).includes(dst)
+        if (!selfModifying) {
+          // Replace with a copy from the already-computed temp
+          instrs.push({ kind: 'copy', dst, src: { kind: 'temp', name: existing } })
+          // But do invalidate any previous mapping for dst if it existed
+          invalidate(dst)
+          continue
+        }
+      }
+    }
+
+    // Process instruction normally
+    const dst = getDst(instr)
+    if (dst !== null) {
+      // Invalidate expressions that used the old value of dst
+      invalidate(dst)
+    }
+
+    if (key !== null && dst !== null) {
+      // Record this new expression
+      available.set(key, dst)
+      // Track which temps this expression depends on
+      const deps = getUsedTemps(instr)
+      recordDep(key, deps)
+    } else if (
+      // Side-effect instructions that may alias-write through external state:
+      // call, call_macro, call_context, score_write, nbt_write, nbt_write_dynamic
+      // These don't define a Temp dst we can track, but they invalidate expressions
+      // that read from the same external state. For safety, clear all non-temp
+      // expressions (conservative approach for local CSE).
+      instr.kind === 'call' ||
+      instr.kind === 'call_macro' ||
+      instr.kind === 'call_context' ||
+      instr.kind === 'score_write' ||
+      instr.kind === 'nbt_write' ||
+      instr.kind === 'nbt_write_dynamic'
+    ) {
+      // For calls and writes, we conservatively clear ALL available expressions
+      // since they may have side effects or alias effects we can't track locally.
+      available.clear()
+      tempDeps.clear()
+    }
+
+    instrs.push(instr)
+  }
+
+  return { ...block, instrs }
+}
+
+// ---------------------------------------------------------------------------
+// Public pass entry point
+// ---------------------------------------------------------------------------
+
+export function cse(fn: MIRFunction): MIRFunction {
+  return {
+    ...fn,
+    blocks: fn.blocks.map(cseBlock),
+  }
+}

package/src/optimizer/dce.ts

@@ -99,7 +99,7 @@ function getTermTargets(term: MIRInstr): BlockId[] {
 function getDst(instr: MIRInstr): Temp | null {
   switch (instr.kind) {
     case 'const': case 'copy':
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
     case 'neg': case 'cmp':
     case 'and': case 'or': case 'not':
     case 'nbt_read':
@@ -121,7 +121,7 @@ function getUsedTemps(instr: MIRInstr): Temp[] {
   switch (instr.kind) {
     case 'copy': case 'neg': case 'not':
       addOp(instr.src); break
-    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod': case 'pow':
     case 'cmp': case 'and': case 'or':
       addOp(instr.a); addOp(instr.b); break
     case 'nbt_write':