redscript-mc 1.0.0

package/src/optimizer/commands.ts

@@ -0,0 +1,416 @@
+import type { IRCommand } from '../ir/types'
+
+export interface OptimizationStats {
+  licmHoists: number
+  licmLoopBodies: number
+  cseRedundantReads: number
+  cseArithmetic: number
+  setblockMergedCommands: number
+  setblockFillCommands: number
+  setblockSavedCommands: number
+  deadCodeRemoved: number
+  constantFolds: number
+  totalCommandsBefore: number
+  totalCommandsAfter: number
+}
+
+export interface CommandFunction {
+  name: string
+  commands: IRCommand[]
+}
+
+const SCOREBOARD_READ_RE =
+  /^execute store result score (\$[A-Za-z0-9_]+) rs run scoreboard players get (\S+) (\S+)$/
+const SCOREBOARD_WRITE_RE =
+  /^(?:scoreboard players (?:set|add|remove|reset)\s+(\S+)\s+(\S+)|scoreboard players operation\s+(\S+)\s+(\S+)\s+[+\-*/%]?= )/
+const EXECUTE_STORE_SCORE_RE =
+  /^execute store result score (\S+) (\S+) run /
+const FUNCTION_CALL_RE = /^execute as (.+) run function ([^:]+):(.+)$/
+const TEMP_RE = /\$[A-Za-z0-9_]+/g
+const SETBLOCK_RE = /^setblock (-?\d+) (-?\d+) (-?\d+) (\S+)$/
+
+export function createEmptyOptimizationStats(): OptimizationStats {
+  return {
+    licmHoists: 0,
+    licmLoopBodies: 0,
+    cseRedundantReads: 0,
+    cseArithmetic: 0,
+    setblockMergedCommands: 0,
+    setblockFillCommands: 0,
+    setblockSavedCommands: 0,
+    deadCodeRemoved: 0,
+    constantFolds: 0,
+    totalCommandsBefore: 0,
+    totalCommandsAfter: 0,
+  }
+}
+
+function cloneCommand(command: IRCommand): IRCommand {
+  return { ...command }
+}
+
+function cloneFunctions(functions: CommandFunction[]): CommandFunction[] {
+  return functions.map(fn => ({
+    name: fn.name,
+    commands: fn.commands.map(cloneCommand),
+  }))
+}
+
+export function mergeOptimizationStats(base: OptimizationStats, delta: Partial<OptimizationStats>): void {
+  for (const [key, value] of Object.entries(delta)) {
+    base[key as keyof OptimizationStats] += value as number
+  }
+}
+
+function parseScoreboardWrite(command: string): { player: string; objective: string } | null {
+  const executeStoreMatch = command.match(EXECUTE_STORE_SCORE_RE)
+  if (executeStoreMatch) {
+    return { player: executeStoreMatch[1], objective: executeStoreMatch[2] }
+  }
+
+  const match = command.match(SCOREBOARD_WRITE_RE)
+  if (!match) {
+    return null
+  }
+
+  if (match[1] && match[2]) {
+    return { player: match[1], objective: match[2] }
+  }
+
+  if (match[3] && match[4]) {
+    return { player: match[3], objective: match[4] }
+  }
+
+  return null
+}
+
+function replaceTemp(command: string, from: string, to: string): string {
+  const re = new RegExp(`\\${from}(?![A-Za-z0-9_])`, 'g')
+  return command.replace(re, to)
+}
+
+function collectObjectiveWrites(functions: CommandFunction[]): Map<string, number> {
+  const writes = new Map<string, number>()
+
+  for (const fn of functions) {
+    for (const command of fn.commands) {
+      const write = parseScoreboardWrite(command.cmd)
+      if (!write) continue
+      writes.set(write.objective, (writes.get(write.objective) ?? 0) + 1)
+    }
+  }
+
+  return writes
+}
+
+function applyLICMInternal(functions: CommandFunction[]): Partial<OptimizationStats> {
+  const stats: Partial<OptimizationStats> = { licmHoists: 0, licmLoopBodies: 0 }
+  const functionMap = new Map(functions.map(fn => [fn.name, fn]))
+  const objectiveWrites = collectObjectiveWrites(functions)
+
+  for (const fn of functions) {
+    const nextCommands: IRCommand[] = []
+
+    for (const command of fn.commands) {
+      const match = command.cmd.match(FUNCTION_CALL_RE)
+      if (!match) {
+        nextCommands.push(command)
+        continue
+      }
+
+      const loopFn = functionMap.get(match[3])
+      if (!loopFn) {
+        nextCommands.push(command)
+        continue
+      }
+
+      const readInfo = new Map<string, { temp: string; player: string; objective: string; uses: number }>()
+      const scoreboardWrites = new Set<string>()
+
+      for (const inner of loopFn.commands) {
+        const readMatch = inner.cmd.match(SCOREBOARD_READ_RE)
+        if (readMatch) {
+          const [, temp, player, objective] = readMatch
+          const key = `${player} ${objective}`
+          readInfo.set(key, { temp, player, objective, uses: 0 })
+        }
+
+        const write = parseScoreboardWrite(inner.cmd)
+        if (write) {
+          scoreboardWrites.add(`${write.player} ${write.objective}`)
+        }
+      }
+
+      for (const inner of loopFn.commands) {
+        for (const info of readInfo.values()) {
+          const matches = inner.cmd.match(TEMP_RE) ?? []
+          const usageCount = matches.filter(name => name === info.temp).length
+          const isDef = inner.cmd.startsWith(`execute store result score ${info.temp} rs run scoreboard players get `)
+          if (!isDef) {
+            info.uses += usageCount
+          }
+        }
+      }
+
+      const hoistable = Array.from(readInfo.entries())
+        .filter(([key, info]) => {
+          if (info.uses < 2) return false
+          if ((objectiveWrites.get(info.objective) ?? 0) !== 0) return false
+          if (scoreboardWrites.has(key)) return false
+          return true
+        })
+        .map(([, info]) => info)
+
+      if (hoistable.length === 0) {
+        nextCommands.push(command)
+        continue
+      }
+
+      const hoistedTemps = new Set(hoistable.map(item => item.temp))
+      const rewrittenLoopCommands: IRCommand[] = []
+
+      for (const inner of loopFn.commands) {
+        const readMatch = inner.cmd.match(SCOREBOARD_READ_RE)
+        if (readMatch && hoistedTemps.has(readMatch[1])) {
+          continue
+        }
+        rewrittenLoopCommands.push(inner)
+      }
+
+      loopFn.commands = rewrittenLoopCommands
+      nextCommands.push(
+        ...hoistable.map(item => ({
+          cmd: `execute store result score ${item.temp} rs run scoreboard players get ${item.player} ${item.objective}`,
+        })),
+        command
+      )
+      stats.licmHoists = (stats.licmHoists ?? 0) + hoistable.length
+      stats.licmLoopBodies = (stats.licmLoopBodies ?? 0) + 1
+    }
+
+    fn.commands = nextCommands
+  }
+
+  return stats
+}
+
+function extractArithmeticExpression(commands: IRCommand[], index: number): { key: string; dst: string } | null {
+  const assign =
+    commands[index]?.cmd.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs = (\$[A-Za-z0-9_]+|\$const_-?\d+) rs$/) ??
+    commands[index]?.cmd.match(/^scoreboard players set (\$[A-Za-z0-9_]+) rs (-?\d+)$/)
+  const op = commands[index + 1]?.cmd.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs ([+\-*/%]=) (\$[A-Za-z0-9_]+|\$const_-?\d+) rs$/)
+  if (!assign || !op || assign[1] !== op[1]) {
+    return null
+  }
+  return {
+    key: `${assign[2]} ${op[2]} ${op[3]}`,
+    dst: assign[1],
+  }
+}
+
+function applyCSEInternal(functions: CommandFunction[]): Partial<OptimizationStats> {
+  const stats: Partial<OptimizationStats> = { cseRedundantReads: 0, cseArithmetic: 0 }
+
+  for (const fn of functions) {
+    const commands = fn.commands.map(cloneCommand)
+    const readCache = new Map<string, string>()
+    const exprCache = new Map<string, string>()
+    const rewritten: IRCommand[] = []
+
+    function invalidateByTemp(temp: string): void {
+      for (const [key, value] of readCache.entries()) {
+        if (value === temp || key.includes(`${temp} `) || key.endsWith(` ${temp}`)) {
+          readCache.delete(key)
+        }
+      }
+      for (const [key, value] of exprCache.entries()) {
+        if (value === temp || key.includes(temp)) {
+          exprCache.delete(key)
+        }
+      }
+    }
+
+    for (let i = 0; i < commands.length; i++) {
+      const command = commands[i]
+      const readMatch = command.cmd.match(SCOREBOARD_READ_RE)
+      if (readMatch) {
+        const [, dst, player, objective] = readMatch
+        const key = `${player} ${objective}`
+        const cached = readCache.get(key)
+        if (cached) {
+          stats.cseRedundantReads = (stats.cseRedundantReads ?? 0) + 1
+          rewritten.push({ ...command, cmd: `scoreboard players operation ${dst} rs = ${cached} rs` })
+        } else {
+          readCache.set(key, dst)
+          rewritten.push(command)
+        }
+        invalidateByTemp(dst)
+        readCache.set(key, dst)
+        continue
+      }
+
+      const expr = extractArithmeticExpression(commands, i)
+      if (expr) {
+        const cached = exprCache.get(expr.key)
+        if (cached) {
+          rewritten.push({ ...commands[i], cmd: `scoreboard players operation ${expr.dst} rs = ${cached} rs` })
+          stats.cseArithmetic = (stats.cseArithmetic ?? 0) + 1
+          i += 1
+        } else {
+          rewritten.push(command)
+          rewritten.push(commands[i + 1])
+          exprCache.set(expr.key, expr.dst)
+          i += 1
+        }
+        invalidateByTemp(expr.dst)
+        exprCache.set(expr.key, expr.dst)
+        continue
+      }
+
+      const write = parseScoreboardWrite(command.cmd)
+      if (write) {
+        readCache.delete(`${write.player} ${write.objective}`)
+        if (write.player.startsWith('$')) {
+          invalidateByTemp(write.player)
+        }
+      }
+
+      rewritten.push(command)
+    }
+
+    fn.commands = rewritten
+  }
+
+  return stats
+}
+
+function batchSetblocksInCommands(commands: IRCommand[]): { commands: IRCommand[]; stats: Partial<OptimizationStats> } {
+  const rewritten: IRCommand[] = []
+  const stats: Partial<OptimizationStats> = {
+    setblockMergedCommands: 0,
+    setblockFillCommands: 0,
+    setblockSavedCommands: 0,
+  }
+
+  for (let i = 0; i < commands.length; ) {
+    const start = commands[i].cmd.match(SETBLOCK_RE)
+    if (!start) {
+      rewritten.push(commands[i])
+      i++
+      continue
+    }
+
+    const block = start[4]
+    const run = [{ index: i, x: Number(start[1]), y: Number(start[2]), z: Number(start[3]) }]
+    let axis: 'x' | 'z' | null = null
+    let j = i + 1
+
+    while (j < commands.length) {
+      const next = commands[j].cmd.match(SETBLOCK_RE)
+      if (!next || next[4] !== block) break
+
+      const point = { x: Number(next[1]), y: Number(next[2]), z: Number(next[3]) }
+      const prev = run[run.length - 1]
+      if (point.y !== prev.y) break
+
+      const stepX = point.x - prev.x
+      const stepZ = point.z - prev.z
+      if (axis === null) {
+        if (stepX === 1 && stepZ === 0) axis = 'x'
+        else if (stepX === 0 && stepZ === 1) axis = 'z'
+        else break
+      }
+
+      const valid = axis === 'x'
+        ? point.z === prev.z && stepX === 1 && stepZ === 0
+        : point.x === prev.x && stepX === 0 && stepZ === 1
+      if (!valid) break
+
+      run.push({ index: j, ...point })
+      j++
+    }
+
+    if (run.length >= 2) {
+      const first = run[0]
+      const last = run[run.length - 1]
+      rewritten.push({
+        ...commands[i],
+        cmd: `fill ${first.x} ${first.y} ${first.z} ${last.x} ${last.y} ${last.z} ${block}`,
+      })
+      stats.setblockMergedCommands = (stats.setblockMergedCommands ?? 0) + run.length
+      stats.setblockFillCommands = (stats.setblockFillCommands ?? 0) + 1
+      stats.setblockSavedCommands = (stats.setblockSavedCommands ?? 0) + (run.length - 1)
+      i = j
+      continue
+    }
+
+    rewritten.push(commands[i])
+    i++
+  }
+
+  return { commands: rewritten, stats }
+}
+
+function applySetblockBatchingInternal(functions: CommandFunction[]): Partial<OptimizationStats> {
+  const stats: Partial<OptimizationStats> = {
+    setblockMergedCommands: 0,
+    setblockFillCommands: 0,
+    setblockSavedCommands: 0,
+  }
+
+  for (const fn of functions) {
+    const batched = batchSetblocksInCommands(fn.commands)
+    fn.commands = batched.commands
+    mergeOptimizationStats(stats as OptimizationStats, batched.stats)
+  }
+
+  return stats
+}
+
+export function applyLICM(functions: CommandFunction[]): { functions: CommandFunction[]; stats: OptimizationStats } {
+  const optimized = cloneFunctions(functions)
+  const stats = createEmptyOptimizationStats()
+  stats.totalCommandsBefore = optimized.reduce((sum, fn) => sum + fn.commands.length, 0)
+  mergeOptimizationStats(stats, applyLICMInternal(optimized))
+  stats.totalCommandsAfter = optimized.reduce((sum, fn) => sum + fn.commands.length, 0)
+  return { functions: optimized, stats }
+}
+
+export function applyCSE(functions: CommandFunction[]): { functions: CommandFunction[]; stats: OptimizationStats } {
+  const optimized = cloneFunctions(functions)
+  const stats = createEmptyOptimizationStats()
+  stats.totalCommandsBefore = optimized.reduce((sum, fn) => sum + fn.commands.length, 0)
+  mergeOptimizationStats(stats, applyCSEInternal(optimized))
+  stats.totalCommandsAfter = optimized.reduce((sum, fn) => sum + fn.commands.length, 0)
+  return { functions: optimized, stats }
+}
+
+export function batchSetblocks(functions: CommandFunction[]): { functions: CommandFunction[]; stats: OptimizationStats } {
+  const optimized = cloneFunctions(functions)
+  const stats = createEmptyOptimizationStats()
+  stats.totalCommandsBefore = optimized.reduce((sum, fn) => sum + fn.commands.length, 0)
+  mergeOptimizationStats(stats, applySetblockBatchingInternal(optimized))
+  stats.totalCommandsAfter = optimized.reduce((sum, fn) => sum + fn.commands.length, 0)
+  return { functions: optimized, stats }
+}
+
+export function optimizeCommandFunctions(functions: CommandFunction[]): { functions: CommandFunction[]; stats: OptimizationStats } {
+  const initial = cloneFunctions(functions)
+  const stats = createEmptyOptimizationStats()
+  stats.totalCommandsBefore = initial.reduce((sum, fn) => sum + fn.commands.length, 0)
+
+  const licm = applyLICM(initial)
+  mergeOptimizationStats(stats, licm.stats)
+
+  const cse = applyCSE(licm.functions)
+  mergeOptimizationStats(stats, cse.stats)
+
+  const batched = batchSetblocks(cse.functions)
+  mergeOptimizationStats(stats, batched.stats)
+  stats.totalCommandsAfter = batched.functions.reduce((sum, fn) => sum + fn.commands.length, 0)
+
+  return {
+    functions: batched.functions,
+    stats,
+  }
+}

package/src/optimizer/passes.ts

@@ -0,0 +1,233 @@
+/**
+ * Optimization passes over IR.
+ *
+ * Each pass: IRFunction → IRFunction  (pure transformation)
+ *
+ * Pipeline order:
+ *   1. constantFolding      — evaluate constant expressions at compile time
+ *   2. copyPropagation      — eliminate redundant copies
+ *   3. deadCodeElimination  — remove unused assignments
+ *   4. commandMerging       — MC-specific: merge chained execute conditions
+ */
+
+import type { IRBlock, IRFunction, IRInstr, Operand } from '../ir/types'
+import { createEmptyOptimizationStats, mergeOptimizationStats, type OptimizationStats } from './commands'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function isConst(op: Operand): op is { kind: 'const'; value: number } {
+  return op.kind === 'const'
+}
+
+function evalBinop(lhs: number, bop: string, rhs: number): number | null {
+  switch (bop) {
+    case '+': return lhs + rhs
+    case '-': return lhs - rhs
+    case '*': return lhs * rhs
+    case '/': return rhs === 0 ? null : Math.trunc(lhs / rhs)  // MC uses truncated int division
+    case '%': return rhs === 0 ? null : lhs % rhs
+    default:  return null
+  }
+}
+
+function evalCmp(lhs: number, cop: string, rhs: number): number {
+  switch (cop) {
+    case '==': return lhs === rhs ? 1 : 0
+    case '!=': return lhs !== rhs ? 1 : 0
+    case '<':  return lhs < rhs ? 1 : 0
+    case '<=': return lhs <= rhs ? 1 : 0
+    case '>':  return lhs > rhs ? 1 : 0
+    case '>=': return lhs >= rhs ? 1 : 0
+    default:   return 0
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Pass 1: Constant Folding
+// Evaluates expressions with all-constant operands at compile time.
+// ---------------------------------------------------------------------------
+
+export function constantFolding(fn: IRFunction): IRFunction {
+  return constantFoldingWithStats(fn).fn
+}
+
+export function constantFoldingWithStats(fn: IRFunction): { fn: IRFunction; stats: Partial<OptimizationStats> } {
+  let folded = 0
+  const newBlocks = fn.blocks.map(block => {
+    const newInstrs: IRInstr[] = []
+    for (const instr of block.instrs) {
+      if (instr.op === 'binop' && isConst(instr.lhs) && isConst(instr.rhs)) {
+        const result = evalBinop(instr.lhs.value, instr.bop, instr.rhs.value)
+        if (result !== null) {
+          folded++
+          newInstrs.push({ op: 'assign', dst: instr.dst, src: { kind: 'const', value: result } })
+          continue
+        }
+      }
+      if (instr.op === 'cmp' && isConst(instr.lhs) && isConst(instr.rhs)) {
+        const result = evalCmp(instr.lhs.value, instr.cop, instr.rhs.value)
+        folded++
+        newInstrs.push({ op: 'assign', dst: instr.dst, src: { kind: 'const', value: result } })
+        continue
+      }
+      newInstrs.push(instr)
+    }
+    return { ...block, instrs: newInstrs }
+  })
+  return { fn: { ...fn, blocks: newBlocks }, stats: { constantFolds: folded } }
+}
+
+// ---------------------------------------------------------------------------
+// Pass 2: Copy Propagation
+// Replaces uses of variables that are just copies with their source.
+// e.g.  t0 = x;  y = t0 + 1  →  y = x + 1
+// ---------------------------------------------------------------------------
+
+export function copyPropagation(fn: IRFunction): IRFunction {
+  // Build copy map within each block (single-block analysis for simplicity)
+  const newBlocks = fn.blocks.map(block => {
+    const copies = new Map<string, Operand>()  // var → its source if it's a copy
+
+    function resolve(op: Operand): Operand {
+      if (op.kind !== 'var') return op
+      return copies.get(op.name) ?? op
+    }
+
+    const newInstrs: IRInstr[] = []
+    for (const instr of block.instrs) {
+      switch (instr.op) {
+        case 'assign': {
+          const src = resolve(instr.src)
+          // Only propagate scalars (var or const), not storage
+          if (src.kind === 'var' || src.kind === 'const') {
+            copies.set(instr.dst, src)
+          } else {
+            copies.delete(instr.dst)
+          }
+          newInstrs.push({ ...instr, src })
+          break
+        }
+        case 'binop':
+          copies.delete(instr.dst)
+          newInstrs.push({ ...instr, lhs: resolve(instr.lhs), rhs: resolve(instr.rhs) })
+          break
+        case 'cmp':
+          copies.delete(instr.dst)
+          newInstrs.push({ ...instr, lhs: resolve(instr.lhs), rhs: resolve(instr.rhs) })
+          break
+        case 'call':
+          if (instr.dst) copies.delete(instr.dst)
+          newInstrs.push({ ...instr, args: instr.args.map(resolve) })
+          break
+        default:
+          newInstrs.push(instr)
+      }
+    }
+    return { ...block, instrs: newInstrs }
+  })
+  return { ...fn, blocks: newBlocks }
+}
+
+// ---------------------------------------------------------------------------
+// Pass 3: Dead Code Elimination
+// Removes assignments to variables that are never read afterward.
+// ---------------------------------------------------------------------------
+
+export function deadCodeElimination(fn: IRFunction): IRFunction {
+  return deadCodeEliminationWithStats(fn).fn
+}
+
+export function deadCodeEliminationWithStats(fn: IRFunction): { fn: IRFunction; stats: Partial<OptimizationStats> } {
+  // Collect all reads across all blocks
+  const readVars = new Set<string>()
+
+  function markRead(op: Operand) {
+    if (op.kind === 'var') readVars.add(op.name)
+  }
+
+  function markRawReads(cmd: string) {
+    for (const match of cmd.matchAll(/\$[A-Za-z0-9_]+/g)) {
+      readVars.add(match[0])
+    }
+  }
+
+  for (const block of fn.blocks) {
+    for (const instr of block.instrs) {
+      if (instr.op === 'binop')   { markRead(instr.lhs); markRead(instr.rhs) }
+      if (instr.op === 'cmp')     { markRead(instr.lhs); markRead(instr.rhs) }
+      if (instr.op === 'call')    { instr.args.forEach(markRead) }
+      if (instr.op === 'assign')  { markRead(instr.src) }
+      if (instr.op === 'raw')     { markRawReads(instr.cmd) }
+    }
+    // Terminator reads
+    const t = block.term
+    if (t.op === 'jump_if' || t.op === 'jump_unless') readVars.add(t.cond)
+    if (t.op === 'return' && t.value) markRead(t.value)
+    if (t.op === 'tick_yield') { /* no reads */ }
+  }
+
+  // Also keep params and globals
+  fn.params.forEach(p => readVars.add(p))
+
+  let removed = 0
+  const newBlocks = fn.blocks.map(block => ({
+    ...block,
+    instrs: block.instrs.filter(instr => {
+      // Only assignments/binops/cmps with an unused dst are candidates for removal
+      if (instr.op === 'assign' || instr.op === 'binop' || instr.op === 'cmp') {
+        const keep = readVars.has(instr.dst)
+        if (!keep) removed++
+        return keep
+      }
+      // calls may have side effects — keep them always
+      return true
+    }),
+  }))
+
+  return { fn: { ...fn, blocks: newBlocks }, stats: { deadCodeRemoved: removed } }
+}
+
+// ---------------------------------------------------------------------------
+// Pipeline
+// ---------------------------------------------------------------------------
+
+export interface OptimizationPass {
+  name: string
+  run: (fn: IRFunction) => IRFunction
+}
+
+export const defaultPipeline: OptimizationPass[] = [
+  { name: 'constant-folding',      run: constantFolding },
+  { name: 'copy-propagation',      run: copyPropagation },
+  { name: 'dead-code-elimination', run: deadCodeElimination },
+  // commandMerging is applied during codegen (MC-specific)
+]
+
+export function optimize(fn: IRFunction, passes = defaultPipeline): IRFunction {
+  return optimizeWithStats(fn, passes).fn
+}
+
+export function optimizeWithStats(fn: IRFunction, passes = defaultPipeline): { fn: IRFunction; stats: OptimizationStats } {
+  let current = fn
+  const stats = createEmptyOptimizationStats()
+
+  for (const pass of passes) {
+    if (pass.name === 'constant-folding') {
+      const result = constantFoldingWithStats(current)
+      current = result.fn
+      mergeOptimizationStats(stats, result.stats)
+      continue
+    }
+    if (pass.name === 'dead-code-elimination') {
+      const result = deadCodeEliminationWithStats(current)
+      current = result.fn
+      mergeOptimizationStats(stats, result.stats)
+      continue
+    }
+    current = pass.run(current)
+  }
+
+  return { fn: current, stats }
+}