redscript-mc 2.0.0 → 2.1.1

package/{src2 → src}/optimizer/dce.ts

@@ -80,8 +80,9 @@ function hasSideEffects(instr: MIRInstr): boolean {
   if (instr.kind === 'call' || instr.kind === 'call_macro' ||
     instr.kind === 'call_context' || instr.kind === 'nbt_write') return true
   // Return field temps (__rf_) write to global return slots — not dead even if unused locally
+  // Option slot temps (__opt_) write observable scoreboard state — preserve even if var unused
   const dst = getDst(instr)
-  if (dst && dst.startsWith('__rf_')) return true
+  if (dst && (dst.startsWith('__rf_') || dst.startsWith('__opt_'))) return true
   return false
 }
 

package/src/optimizer/interprocedural.ts

@@ -0,0 +1,177 @@
+/**
+ * Interprocedural Constant Propagation — MIR module-level optimization pass.
+ *
+ * For each call site where all arguments are compile-time constants, creates
+ * a specialized clone of the callee with the parameters substituted as
+ * constants, then runs constant folding on the clone.
+ *
+ * Specialized function naming: `original__const_N1_N2_...` where N1, N2 are
+ * the constant argument values.
+ *
+ * This pass iterates to fixpoint to handle transitively specialized callees.
+ */
+
+import type { MIRFunction, MIRModule, MIRBlock, MIRInstr, Operand, Temp } from '../mir/types'
+import { constantFold } from './constant_fold'
+
+export function interproceduralConstProp(mod: MIRModule): MIRModule {
+  let current = mod
+  // Iterate to fixpoint (new specializations may enable further specializations)
+  for (let i = 0; i < 10; i++) {
+    const next = runOnePass(current)
+    if (next.functions.length === current.functions.length &&
+        JSON.stringify(next.functions.map(f => f.name)) === JSON.stringify(current.functions.map(f => f.name))) {
+      // No new specializations
+      return next
+    }
+    current = next
+  }
+  return current
+}
+
+function runOnePass(mod: MIRModule): MIRModule {
+  const fnMap = new Map<string, MIRFunction>(mod.functions.map(f => [f.name, f]))
+  const newFunctions: MIRFunction[] = [...mod.functions]
+  const added = new Set<string>()
+
+  for (const fn of mod.functions) {
+    for (const block of fn.blocks) {
+      for (const instr of block.instrs) {
+        if (instr.kind !== 'call') continue
+        if (instr.args.length === 0) continue
+        if (!instr.args.every(a => a.kind === 'const')) continue
+
+        const callee = fnMap.get(instr.fn)
+        if (!callee) continue
+        if (callee.isMacro) continue
+        if (callee.name === fn.name) continue // no direct recursion at call site
+        if (callee.params.length !== instr.args.length) continue
+        // Skip if the callee is self-recursive (would cause infinite specialization)
+        if (isSelfRecursive(callee)) continue
+        // Only specialize single-block (loop-free) functions — loop bodies mutate
+        // variables in ways that make constant-param substitution unsafe.
+        if (callee.blocks.length > 1) continue
+
+        const constArgs = instr.args as { kind: 'const'; value: number }[]
+        const mangledName = mangleName(instr.fn, constArgs.map(a => a.value))
+
+        if (fnMap.has(mangledName) || added.has(mangledName)) continue
+
+        // Create specialized clone
+        const specialized = specialize(callee, constArgs.map(a => a.value), mangledName)
+        newFunctions.push(specialized)
+        added.add(mangledName)
+        fnMap.set(mangledName, specialized)
+      }
+    }
+  }
+
+  if (added.size === 0) return mod
+
+  // Rewrite call sites to use specialized names
+  const updatedFunctions = newFunctions.map(fn => rewriteCallSites(fn, fnMap))
+
+  return { ...mod, functions: updatedFunctions }
+}
+
+/** Returns true if the function contains a call to itself (direct recursion). */
+function isSelfRecursive(fn: MIRFunction): boolean {
+  for (const block of fn.blocks) {
+    for (const instr of block.instrs) {
+      if (instr.kind === 'call' && instr.fn === fn.name) return true
+      if (instr.kind === 'call_macro' && instr.fn === fn.name) return true
+    }
+  }
+  return false
+}
+
+function mangleName(name: string, args: number[]): string {
+  return `${name}__const_${args.map(v => v < 0 ? `n${Math.abs(v)}` : String(v)).join('_')}`
+}
+
+function specialize(fn: MIRFunction, args: number[], newName: string): MIRFunction {
+  // Build substitution map: param.name → const operand
+  const sub = new Map<Temp, Operand>()
+  for (let i = 0; i < fn.params.length; i++) {
+    sub.set(fn.params[i].name, { kind: 'const', value: args[i] })
+  }
+
+  const newBlocks = fn.blocks.map(block => substituteBlock(block, sub))
+  const specialized: MIRFunction = {
+    ...fn,
+    name: newName,
+    params: [], // no params — all specialized
+    blocks: newBlocks,
+    isMacro: false,
+  }
+
+  // Run constant folding on the specialized function
+  return constantFold(specialized)
+}
+
+function substituteBlock(block: MIRBlock, sub: Map<Temp, Operand>): MIRBlock {
+  const instrs = block.instrs.map(instr => substituteInstr(instr, sub))
+  const term = substituteInstr(block.term, sub)
+  return { ...block, instrs, term }
+}
+
+function substituteOp(op: Operand, sub: Map<Temp, Operand>): Operand {
+  if (op.kind === 'temp') {
+    const replacement = sub.get(op.name)
+    if (replacement !== undefined) return replacement
+  }
+  return op
+}
+
+function substituteInstr(instr: MIRInstr, sub: Map<Temp, Operand>): MIRInstr {
+  switch (instr.kind) {
+    case 'copy': return { ...instr, src: substituteOp(instr.src, sub) }
+    case 'neg': case 'not': return { ...instr, src: substituteOp(instr.src, sub) }
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'and': case 'or':
+      return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) }
+    case 'cmp':
+      return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) }
+    case 'nbt_write':
+      return { ...instr, src: substituteOp(instr.src, sub) }
+    case 'call':
+      return { ...instr, args: instr.args.map(a => substituteOp(a, sub)) }
+    case 'call_macro':
+      return { ...instr, args: instr.args.map(a => ({ ...a, value: substituteOp(a.value, sub) })) }
+    case 'branch':
+      return { ...instr, cond: substituteOp(instr.cond, sub) }
+    case 'return':
+      return { ...instr, value: instr.value ? substituteOp(instr.value, sub) : null }
+    default:
+      return instr
+  }
+}
+
+function rewriteCallSites(fn: MIRFunction, fnMap: Map<string, MIRFunction>): MIRFunction {
+  return {
+    ...fn,
+    blocks: fn.blocks.map(block => ({
+      ...block,
+      instrs: block.instrs.map(instr => {
+        if (instr.kind !== 'call') return instr
+        if (!instr.args.every(a => a.kind === 'const')) return instr
+        const callee = fnMap.get(instr.fn)
+        if (!callee) return instr
+        if (callee.isMacro) return instr
+        if (callee.name === fn.name) return instr
+        if (callee.params.length !== instr.args.length) return instr
+
+        const constArgs = instr.args as { kind: 'const'; value: number }[]
+        const mangledName = mangleName(instr.fn, constArgs.map(a => a.value))
+        if (!fnMap.has(mangledName)) return instr
+
+        return { ...instr, fn: mangledName, args: [] }
+      }),
+      term: (() => {
+        const term = block.term
+        if (term.kind !== 'call') return term
+        return term
+      })(),
+    })),
+  }
+}

package/src/optimizer/lir/const_imm.ts

@@ -0,0 +1,143 @@
+/**
+ * Constant Immediate Folding — LIR optimization pass.
+ *
+ * Peephole: finds score_set($__const_C, C) immediately followed by
+ * score_add/score_sub(dst, $__const_C), where $__const_C has no other
+ * uses in the function, and replaces the pair with a single
+ * `scoreboard players add/remove` raw command.
+ *
+ * This saves one command per arithmetic-with-constant operation.
+ */
+
+import type { LIRFunction, LIRInstr, Slot } from '../../lir/types'
+
+function slotKey(s: Slot): string {
+  return `${s.player}\0${s.obj}`
+}
+
+/** Count how many times a slot is used as a source operand. */
+function countSlotUses(instrs: LIRInstr[], target: string): number {
+  let count = 0
+  for (const instr of instrs) {
+    for (const s of getReadSlots(instr)) {
+      if (slotKey(s) === target) count++
+    }
+  }
+  return count
+}
+
+function extractSlotsFromRaw(cmd: string): Slot[] {
+  const slots: Slot[] = []
+  const re = /(\$[\w.]+)\s+(\S+)/g
+  let m
+  while ((m = re.exec(cmd)) !== null) {
+    slots.push({ player: m[1], obj: m[2] })
+  }
+  return slots
+}
+
+function getReadSlots(instr: LIRInstr): Slot[] {
+  switch (instr.kind) {
+    case 'score_copy': return [instr.src]
+    case 'score_add': case 'score_sub':
+    case 'score_mul': case 'score_div': case 'score_mod':
+    case 'score_min': case 'score_max':
+      return [instr.src]
+    case 'score_swap': return [instr.a, instr.b]
+    case 'store_cmd_to_score': return getReadSlots(instr.cmd)
+    case 'store_score_to_nbt': return [instr.src]
+    case 'return_value': return [instr.slot]
+    case 'call_if_matches': case 'call_unless_matches':
+      return [instr.slot]
+    case 'call_if_score': case 'call_unless_score':
+      return [instr.a, instr.b]
+    case 'raw': return extractSlotsFromRaw(instr.cmd)
+    case 'macro_line': return extractSlotsFromRaw(instr.template)
+    default: return []
+  }
+}
+
+export function constImmFold(fn: LIRFunction): LIRFunction {
+  const instrs = fn.instructions
+  if (instrs.length < 2) return fn
+
+  // Pre-compute use counts for all const slots
+  const useCounts = new Map<string, number>()
+  for (const instr of instrs) {
+    for (const s of getReadSlots(instr)) {
+      const key = slotKey(s)
+      useCounts.set(key, (useCounts.get(key) || 0) + 1)
+    }
+  }
+
+  const result: LIRInstr[] = []
+  let changed = false
+  let i = 0
+
+  while (i < instrs.length) {
+    const curr = instrs[i]
+    const next = instrs[i + 1]
+
+    // Pattern: score_set(constSlot, C) + score_add/sub(dst, constSlot)
+    if (
+      next &&
+      curr.kind === 'score_set' &&
+      curr.dst.player.startsWith('$__const_') &&
+      (next.kind === 'score_add' || next.kind === 'score_sub') &&
+      slotKey(next.src) === slotKey(curr.dst) &&
+      (useCounts.get(slotKey(curr.dst)) || 0) === 1
+    ) {
+      const C = curr.value
+      const dst = next.dst
+
+      if (C === 0 && next.kind === 'score_add') {
+        // add 0 is a no-op — skip both
+        changed = true
+        i += 2
+        continue
+      }
+
+      if (C === 0 && next.kind === 'score_sub') {
+        // sub 0 is a no-op — skip both
+        changed = true
+        i += 2
+        continue
+      }
+
+      // Determine add vs remove
+      let op: string
+      let val: number
+      if (next.kind === 'score_add') {
+        if (C > 0) {
+          op = 'add'
+          val = C
+        } else {
+          op = 'remove'
+          val = -C
+        }
+      } else {
+        // score_sub
+        if (C > 0) {
+          op = 'remove'
+          val = C
+        } else {
+          op = 'add'
+          val = -C
+        }
+      }
+
+      result.push({
+        kind: 'raw',
+        cmd: `scoreboard players ${op} ${dst.player} ${dst.obj} ${val}`,
+      })
+      changed = true
+      i += 2
+      continue
+    }
+
+    result.push(curr)
+    i++
+  }
+
+  return changed ? { ...fn, instructions: result } : fn
+}

package/src/optimizer/lir/dead_slot.ts

@@ -0,0 +1,123 @@
+/**
+ * Dead Slot Elimination — LIR optimization pass.
+ *
+ * Removes score_set / score_copy instructions where the destination slot
+ * is never read anywhere in the function.
+ *
+ * Preserves writes to:
+ *  - $ret (return value)
+ *  - $p0, $p1, … (parameter passing slots)
+ *  - slots used in side-effectful instructions (calls, stores, nbt ops, raw)
+ */
+
+import type { LIRFunction, LIRInstr, LIRModule, Slot } from '../../lir/types'
+
+/** Canonical key for a slot (player + obj). */
+function slotKey(s: Slot): string {
+  return `${s.player}\0${s.obj}`
+}
+
+/**
+ * Extract slot references from a raw MC command string.
+ * Matches patterns like `$player_name objective_name` used in scoreboard commands.
+ */
+function extractSlotsFromRaw(cmd: string): Slot[] {
+  const slots: Slot[] = []
+  // Match $<player> <obj> patterns (scoreboard slot references)
+  const re = /(\$[\w.]+)\s+(\S+)/g
+  let m
+  while ((m = re.exec(cmd)) !== null) {
+    slots.push({ player: m[1], obj: m[2] })
+  }
+  return slots
+}
+
+/** Collect all slots that are *read* (used as source) by an instruction. */
+function getReadSlots(instr: LIRInstr): Slot[] {
+  switch (instr.kind) {
+    case 'score_copy': return [instr.src]
+    case 'score_add': case 'score_sub':
+    case 'score_mul': case 'score_div': case 'score_mod':
+    case 'score_min': case 'score_max':
+      return [instr.src]
+    case 'score_swap': return [instr.a, instr.b]
+    case 'store_cmd_to_score': return getReadSlots(instr.cmd)
+    case 'store_score_to_nbt': return [instr.src]
+    case 'store_nbt_to_score': return []
+    case 'return_value': return [instr.slot]
+    case 'call_if_matches': case 'call_unless_matches':
+      return [instr.slot]
+    case 'call_if_score': case 'call_unless_score':
+      return [instr.a, instr.b]
+    case 'raw': return extractSlotsFromRaw(instr.cmd)
+    case 'macro_line': return extractSlotsFromRaw(instr.template)
+    default: return []
+  }
+}
+
+/** Returns the destination slot if the instruction is a pure write (no side effects). */
+function getPureWriteDst(instr: LIRInstr): Slot | null {
+  switch (instr.kind) {
+    case 'score_set': return instr.dst
+    case 'score_copy': return instr.dst
+    default: return null
+  }
+}
+
+/** True if a slot should never be eliminated (externally visible). */
+function isProtectedSlot(s: Slot): boolean {
+  const p = s.player
+  if (p === '$ret' || p.startsWith('$ret_') || /^\$p\d+$/.test(p)) return true
+  // Option slots: __opt_ prefix ensures they're always written to scoreboard
+  // even when the variable appears unused locally
+  if (p.includes('__opt_')) return true
+  return false
+}
+
+export function deadSlotElim(fn: LIRFunction): LIRFunction {
+  // 1. Collect all read slots across the function
+  const readSet = new Set<string>()
+  for (const instr of fn.instructions) {
+    for (const s of getReadSlots(instr)) {
+      readSet.add(slotKey(s))
+    }
+  }
+
+  // 2. Filter out pure writes to slots that are never read
+  const filtered = fn.instructions.filter(instr => {
+    const dst = getPureWriteDst(instr)
+    if (dst === null) return true // not a pure write → keep
+    if (isProtectedSlot(dst)) return true
+    return readSet.has(slotKey(dst))
+  })
+
+  if (filtered.length === fn.instructions.length) return fn
+  return { ...fn, instructions: filtered }
+}
+
+export function deadSlotElimModule(mod: LIRModule): LIRModule {
+  // Collect all slots read across ALL functions (cross-function visibility)
+  const globalReadSet = new Set<string>()
+  for (const fn of mod.functions) {
+    for (const instr of fn.instructions) {
+      for (const s of getReadSlots(instr)) {
+        globalReadSet.add(slotKey(s))
+      }
+    }
+  }
+
+  let changed = false
+  const functions = mod.functions.map(fn => {
+    const filtered = fn.instructions.filter(instr => {
+      const dst = getPureWriteDst(instr)
+      if (dst === null) return true
+      if (isProtectedSlot(dst)) return true
+      return globalReadSet.has(slotKey(dst))
+    })
+    if (filtered.length !== fn.instructions.length) changed = true
+    if (filtered.length === fn.instructions.length) return fn
+    return { ...fn, instructions: filtered }
+  })
+
+  return changed ? { ...mod, functions } : mod
+}

package/src/optimizer/lir/peephole.ts

@@ -0,0 +1,57 @@
+/**
+ * Execute-Store Peephole Pass — LIR optimization pass.
+ *
+ * Merges a `call_context` immediately followed by `score_set(dst, value)`
+ * into a single `store_cmd_to_score` instruction:
+ *
+ *   execute [subcommands] run function ns:fn      ← call_context
+ *   scoreboard players set $result __ns N         ← score_set
+ *
+ * becomes:
+ *
+ *   execute store result score $result __ns [subcommands] run function ns:fn
+ *
+ * This saves one command when the caller only needs to know whether the
+ * execute chain ran (success = 1) or to capture the function's return value.
+ *
+ * Safety: only merges when the two instructions are immediately adjacent
+ * (no instructions between them).
+ */
+
+import type { LIRFunction, LIRInstr } from '../../lir/types'
+
+export function execStorePeephole(fn: LIRFunction): LIRFunction {
+  const instrs = fn.instructions
+  if (instrs.length < 2) return fn
+
+  const result: LIRInstr[] = []
+  let changed = false
+  let i = 0
+
+  while (i < instrs.length) {
+    const curr = instrs[i]
+    const next = instrs[i + 1]
+
+    // Pattern: call_context immediately followed by score_set
+    if (
+      next &&
+      curr.kind === 'call_context' &&
+      next.kind === 'score_set'
+    ) {
+      // Merge: execute store result score <dst> [subcommands] run function <fn>
+      result.push({
+        kind: 'store_cmd_to_score',
+        dst: next.dst,
+        cmd: curr,
+      })
+      changed = true
+      i += 2
+      continue
+    }
+
+    result.push(curr)
+    i++
+  }
+
+  return changed ? { ...fn, instructions: result } : fn
+}

package/src/optimizer/lir/pipeline.ts

@@ -0,0 +1,37 @@
+/**
+ * LIR Optimization Pipeline — runs all LIR passes on a module.
+ *
+ * Pass order: dead_slot → const_imm
+ * Dead slot runs first to remove unused writes, exposing more
+ * single-use const slots for const_imm to fold.
+ */
+
+import type { LIRFunction, LIRModule } from '../../lir/types'
+import { deadSlotElimModule } from './dead_slot'
+import { constImmFold } from './const_imm'
+import { execStorePeephole } from './peephole'
+
+export type LIRPass = (fn: LIRFunction) => LIRFunction
+
+const perFunctionPasses: LIRPass[] = [
+  execStorePeephole,
+  constImmFold,
+]
+
+export function lirOptimizeModule(mod: LIRModule): LIRModule {
+  // Module-level pass: dead slot elimination (cross-function analysis)
+  let result = deadSlotElimModule(mod)
+
+  // Per-function passes
+  let changed = false
+  const functions = result.functions.map(fn => {
+    let current = fn
+    for (const pass of perFunctionPasses) {
+      current = pass(current)
+    }
+    if (current !== fn) changed = true
+    return current
+  })
+
+  return changed ? { ...result, functions } : result
+}

package/src/optimizer/nbt-batch.ts

@@ -0,0 +1,50 @@
+/**
+ * NBT Batch Read — MIR optimization pass.
+ *
+ * Eliminates redundant nbt_read instructions within a basic block:
+ * if the same (ns, path, scale) is read twice with no intervening nbt_write
+ * to that ns, the second read is replaced with a copy from the first read's dst.
+ *
+ * This reduces expensive `data get` commands in generated .mcfunction files.
+ */
+
+import type { MIRFunction, MIRBlock, MIRInstr, Temp } from '../mir/types'
+
+export function nbtBatchRead(fn: MIRFunction): MIRFunction {
+  return {
+    ...fn,
+    blocks: fn.blocks.map(deduplicateBlock),
+  }
+}
+
+function deduplicateBlock(block: MIRBlock): MIRBlock {
+  // Map from "ns\0path\0scale" → dst temp of the first read
+  const cache = new Map<string, Temp>()
+
+  const instrs: MIRInstr[] = []
+  for (const instr of block.instrs) {
+    if (instr.kind === 'nbt_read') {
+      const key = `${instr.ns}\0${instr.path}\0${instr.scale}`
+      const cached = cache.get(key)
+      if (cached !== undefined) {
+        // Replace with copy from cached temp
+        instrs.push({ kind: 'copy', dst: instr.dst, src: { kind: 'temp', name: cached } })
+      } else {
+        cache.set(key, instr.dst)
+        instrs.push(instr)
+      }
+    } else if (instr.kind === 'nbt_write') {
+      // Invalidate all cached reads for this ns
+      for (const key of [...cache.keys()]) {
+        if (key.startsWith(instr.ns + '\0')) {
+          cache.delete(key)
+        }
+      }
+      instrs.push(instr)
+    } else {
+      instrs.push(instr)
+    }
+  }
+
+  return { ...block, instrs }
+}

package/{src2 → src}/optimizer/pipeline.ts

@@ -3,6 +3,9 @@
  *
  * Each pass is a function MIRFunction → MIRFunction.
  * The pipeline iterates until no pass changes the function (fixpoint).
+ *
+ * Module-level passes (interproceduralConstProp) run once after the
+ * per-function fixpoint loop.
  */
 
 import type { MIRFunction, MIRModule } from '../mir/types'
@@ -11,10 +14,20 @@ import { copyProp } from './copy_prop'
 import { dce } from './dce'
 import { blockMerge } from './block_merge'
 import { branchSimplify } from './branch_simplify'
+import { loopUnroll } from './unroll'
+import { nbtBatchRead } from './nbt-batch'
+import { interproceduralConstProp } from './interprocedural'
+
+// selectorCache is intentionally excluded from the default pipeline:
+// it emits synthetic __sel_cleanup_* / __sel_tag_* call_context instructions
+// that require codegen support before being used end-to-end.
+export { selectorCache } from './selector-cache'
 
 export type Pass = (fn: MIRFunction) => MIRFunction
 
 const defaultPasses: Pass[] = [
+  loopUnroll,
+  nbtBatchRead,
   constantFold,
   copyProp,
   branchSimplify,
@@ -37,8 +50,10 @@ export function optimizeFunction(fn: MIRFunction, passes: Pass[] = defaultPasses
 }
 
 export function optimizeModule(mod: MIRModule, passes?: Pass[]): MIRModule {
-  return {
+  const perFnOptimized = {
     ...mod,
     functions: mod.functions.map(fn => optimizeFunction(fn, passes)),
   }
+  // Module-level pass: interprocedural constant propagation
+  return interproceduralConstProp(perFnOptimized)
 }