redscript-mc 1.2.30 → 2.1.0

package/src/optimizer/passes.ts

@@ -1,250 +0,0 @@
-/**
- * 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
-    }
-
-    /**
-     * Invalidate all copies that became stale because `written` was modified.
-     * When $y is overwritten, any mapping copies[$tmp] = $y is now stale:
-     * reading $tmp would return the OLD $y value via the copy, but $y now holds
-     * a different value.  Remove both the direct entry (copies[$y]) and every
-     * reverse entry that points at $y.
-     */
-    function invalidate(written: string): void {
-      copies.delete(written)
-      for (const [k, v] of copies) {
-        if (v.kind === 'var' && v.name === written) copies.delete(k)
-      }
-    }
-
-    const newInstrs: IRInstr[] = []
-    for (const instr of block.instrs) {
-      switch (instr.op) {
-        case 'assign': {
-          const src = resolve(instr.src)
-          invalidate(instr.dst)
-          // Only propagate scalars (var or const), not storage
-          if (src.kind === 'var' || src.kind === 'const') {
-            copies.set(instr.dst, src)
-          }
-          newInstrs.push({ ...instr, src })
-          break
-        }
-        case 'binop':
-          invalidate(instr.dst)
-          newInstrs.push({ ...instr, lhs: resolve(instr.lhs), rhs: resolve(instr.rhs) })
-          break
-        case 'cmp':
-          invalidate(instr.dst)
-          newInstrs.push({ ...instr, lhs: resolve(instr.lhs), rhs: resolve(instr.rhs) })
-          break
-        case 'call':
-          if (instr.dst) invalidate(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') {
-        // Always keep assignments to global variables (they may be read by other functions)
-        // Temps are $t0, $t1, ...; params are $p0, $p1, ...; locals are $_0, $_1, ...
-        // Everything else is a potential global
-        const isTemp = /^\$t\d+$/.test(instr.dst) || /^\$p\d+$/.test(instr.dst) || /^\$_\d+$/.test(instr.dst)
-        const keep = !isTemp || 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 }
-}

package/src/optimizer/structure.ts

@@ -1,450 +0,0 @@
-import type { IRBlock, IRCommand, IRFunction, IRInstr, Operand, Terminator } from '../ir/types'
-import { createEmptyOptimizationStats, mergeOptimizationStats, optimizeCommandFunctions, setOptimizerObjective, type OptimizationStats } from './commands'
-
-let OBJ = 'rs'
-export function setStructureObjective(obj: string): void {
-  OBJ = obj
-  setOptimizerObjective(obj)
-}
-const INLINE_THRESHOLD = 8
-
-const BOP_OP: Record<string, string> = {
-  '+': '+=',
-  '-': '-=',
-  '*': '*=',
-  '/': '/=',
-  '%': '%=',
-}
-
-interface InlineBlock {
-  commands: IRCommand[]
-  continuation?: string
-}
-
-function varRef(name: string): string {
-  return name.startsWith('$') ? name : `$${name}`
-}
-
-function operandToScore(op: Operand): string {
-  if (op.kind === 'var') return `${varRef(op.name)} ${OBJ}`
-  if (op.kind === 'const') return `$const_${op.value} ${OBJ}`
-  if (op.kind === 'param') return `$p${op.index} ${OBJ}`
-  throw new Error(`Cannot convert storage operand to score: ${(op as any).path}`)
-}
-
-function emitInstr(instr: IRInstr, namespace: string): IRCommand[] {
-  const commands: IRCommand[] = []
-
-  switch (instr.op) {
-    case 'assign':
-      if (instr.src.kind === 'const') {
-        commands.push({ cmd: `scoreboard players set ${varRef(instr.dst)} ${OBJ} ${instr.src.value}` })
-      } else if (instr.src.kind === 'var') {
-        commands.push({
-          cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} = ${varRef(instr.src.name)} ${OBJ}`,
-        })
-      } else if (instr.src.kind === 'param') {
-        commands.push({
-          cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} = $p${instr.src.index} ${OBJ}`,
-        })
-      } else {
-        commands.push({
-          cmd: `execute store result score ${varRef(instr.dst)} ${OBJ} run data get storage ${instr.src.path}`,
-        })
-      }
-      break
-
-    case 'binop':
-      commands.push(...emitInstr({ op: 'assign', dst: instr.dst, src: instr.lhs }, namespace))
-      commands.push({
-        cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} ${BOP_OP[instr.bop]} ${operandToScore(instr.rhs)}`,
-      })
-      break
-
-    case 'cmp': {
-      const dst = varRef(instr.dst)
-      const lhs = operandToScore(instr.lhs)
-      const rhs = operandToScore(instr.rhs)
-      commands.push({ cmd: `scoreboard players set ${dst} ${OBJ} 0` })
-      const op =
-        instr.cop === '==' ? 'if score' :
-        instr.cop === '!=' ? 'unless score' :
-        instr.cop === '<' ? 'if score' :
-        instr.cop === '<=' ? 'if score' :
-        instr.cop === '>' ? 'if score' :
-        'if score'
-      const cmp =
-        instr.cop === '==' || instr.cop === '!=' ? '=' :
-        instr.cop
-      commands.push({
-        cmd: `execute ${op} ${lhs} ${cmp} ${rhs} run scoreboard players set ${dst} ${OBJ} 1`,
-      })
-      break
-    }
-
-    case 'call':
-      for (let i = 0; i < instr.args.length; i++) {
-        commands.push(...emitInstr({ op: 'assign', dst: `$p${i}`, src: instr.args[i] }, namespace))
-      }
-      commands.push({ cmd: `function ${namespace}:${instr.fn}` })
-      if (instr.dst) {
-        commands.push({
-          cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} = $ret ${OBJ}`,
-        })
-      }
-      break
-
-    case 'raw':
-      commands.push({ cmd: instr.cmd })
-      break
-  }
-
-  return commands
-}
-
-function emitReturn(term: Extract<Terminator, { op: 'return' }>): IRCommand[] {
-  const commands: IRCommand[] = []
-  if (term.value) {
-    commands.push(...emitInstr({ op: 'assign', dst: '$ret', src: term.value }, ''))
-  }
-  if (term.value?.kind === 'const') {
-    commands.push({ cmd: `return ${term.value.value}` })
-  } else if (term.value?.kind === 'var') {
-    commands.push({ cmd: `return run scoreboard players get ${varRef(term.value.name)} ${OBJ}` })
-  }
-  return commands
-}
-
-function markConditional(commands: IRCommand[]): IRCommand[] {
-  return commands.map(command => ({
-    ...command,
-    conditional: true,
-  }))
-}
-
-function cloneVisited(visited: Set<string>): Set<string> {
-  return new Set(visited)
-}
-
-function isRecursiveCommand(command: string, currentFn: string, namespace: string): boolean {
-  return command.includes(`function ${namespace}:${currentFn}`)
-}
-
-function getInlineableBlock(
-  block: IRBlock | undefined,
-  currentFn: string,
-  namespace: string
-): InlineBlock | null {
-  if (!block) return null
-  if (block.term.op === 'jump_if' || block.term.op === 'jump_unless' || block.term.op === 'tick_yield') {
-    return null
-  }
-
-  const commands = block.instrs.flatMap(instr => emitInstr(instr, namespace))
-  if (commands.some(command => isRecursiveCommand(command.cmd, currentFn, namespace))) {
-    return null
-  }
-
-  if (block.term.op === 'return') {
-    commands.push(...emitReturn(block.term))
-  }
-
-  if (commands.length > INLINE_THRESHOLD) {
-    return null
-  }
-
-  return {
-    commands,
-    continuation: block.term.op === 'jump' ? block.term.target : undefined,
-  }
-}
-
-function flattenBlock(
-  fn: IRFunction,
-  label: string,
-  namespace: string,
-  visited: Set<string>
-): IRCommand[] {
-  const blockMap = new Map(fn.blocks.map(block => [block.label, block]))
-  const block = blockMap.get(label)
-  if (!block) {
-    return []
-  }
-
-  if (visited.has(label)) {
-    return [{ cmd: `function ${namespace}:${fn.name}/${label}`, label }]
-  }
-
-  visited.add(label)
-
-  const commands: IRCommand[] = []
-  if (label === fn.blocks[0]?.label) {
-    for (let i = 0; i < fn.params.length; i++) {
-      commands.push({
-        cmd: `scoreboard players operation ${varRef(fn.params[i])} ${OBJ} = $p${i} ${OBJ}`,
-      })
-    }
-  }
-  commands.push(...block.instrs.flatMap(instr => emitInstr(instr, namespace)))
-  const term = block.term
-
-  switch (term.op) {
-    case 'jump':
-      commands.push(...flattenBlock(fn, term.target, namespace, visited))
-      return commands
-
-    case 'jump_if':
-    case 'jump_unless': {
-      const trueLabel = term.op === 'jump_if' ? term.then : term.else_
-      const falseLabel = term.op === 'jump_if' ? term.else_ : term.then
-      const trueRange = term.op === 'jump_if' ? '1..' : '..0'
-      const falseRange = term.op === 'jump_if' ? '..0' : '1..'
-      const trueBlock = getInlineableBlock(blockMap.get(trueLabel), fn.name, namespace)
-      const falseBlock = getInlineableBlock(blockMap.get(falseLabel), fn.name, namespace)
-
-      if (trueBlock && falseBlock) {
-        if (trueBlock.commands.length > 0) {
-          commands.push({ cmd: `execute if score ${varRef(term.cond)} ${OBJ} matches ${trueRange}`, label: trueLabel })
-          commands.push(...markConditional(trueBlock.commands))
-        }
-        if (falseBlock.commands.length > 0) {
-          commands.push({ cmd: `execute if score ${varRef(term.cond)} ${OBJ} matches ${falseRange}`, label: falseLabel })
-          commands.push(...markConditional(falseBlock.commands))
-        }
-
-        const continuation = trueBlock.continuation && trueBlock.continuation === falseBlock.continuation
-          ? trueBlock.continuation
-          : undefined
-        if (continuation) {
-          commands.push(...flattenBlock(fn, continuation, namespace, cloneVisited(visited)))
-        }
-        return commands
-      }
-
-      commands.push({ cmd: `execute if score ${varRef(term.cond)} ${OBJ} matches ${trueRange} run function ${namespace}:${fn.name}/${trueLabel}` })
-      commands.push({ cmd: `execute if score ${varRef(term.cond)} ${OBJ} matches ${falseRange} run function ${namespace}:${fn.name}/${falseLabel}` })
-      return commands
-    }
-
-    case 'return':
-      commands.push(...emitReturn(term))
-      return commands
-
-    case 'tick_yield':
-      commands.push({ cmd: `schedule function ${namespace}:${fn.name}/${term.continuation} 1t replace` })
-      return commands
-  }
-}
-
-function findVars(command: string): string[] {
-  return Array.from(command.matchAll(/\$[A-Za-z0-9_]+/g), match => match[0])
-}
-
-function parsePureWrite(command: string): { dst: string; reads: string[] } | null {
-  let match = command.match(/^scoreboard players set (\$[A-Za-z0-9_]+) rs -?\d+$/)
-  if (match) {
-    return { dst: match[1], reads: [] }
-  }
-
-  match = command.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs = (\$[A-Za-z0-9_]+) rs$/)
-  if (match) {
-    return { dst: match[1], reads: [match[2]] }
-  }
-
-  match = command.match(/^execute .* run scoreboard players set (\$[A-Za-z0-9_]+) rs -?\d+$/)
-  if (match) {
-    return {
-      dst: match[1],
-      reads: findVars(command).filter(name => name !== match![1]),
-    }
-  }
-
-  return null
-}
-
-function deadStoreEliminate(commands: IRCommand[]): IRCommand[] {
-  const live = new Set<string>()
-  const kept: IRCommand[] = []
-
-  for (let i = commands.length - 1; i >= 0; i--) {
-    const command = commands[i]
-    const pureWrite = parsePureWrite(command.cmd)
-
-    if (pureWrite) {
-      pureWrite.reads.forEach(name => live.add(name))
-      if (!live.has(pureWrite.dst)) {
-        continue
-      }
-      live.delete(pureWrite.dst)
-      kept.push(command)
-      continue
-    }
-
-    findVars(command.cmd).forEach(name => live.add(name))
-    kept.push(command)
-  }
-
-  return kept.reverse()
-}
-
-function isInlineableFunction(
-  fn: IRFunction | undefined,
-  currentFn: string,
-  namespace: string
-): fn is IRFunction & { commands: IRCommand[] } {
-  if (!fn?.commands || fn.name === currentFn || fn.commands.length > INLINE_THRESHOLD) {
-    return false
-  }
-
-  return !fn.commands.some(command =>
-    isRecursiveCommand(command.cmd, currentFn, namespace) ||
-    isRecursiveCommand(command.cmd, fn.name, namespace)
-  )
-}
-
-function inlineConditionalCalls(
-  commands: IRCommand[],
-  functions: Map<string, IRFunction>,
-  currentFn: string,
-  namespace: string
-): IRCommand[] {
-  const optimized: IRCommand[] = []
-
-  for (const command of commands) {
-    const match = command.cmd.match(/^(execute .+) run function ([^:]+):(.+)$/)
-    if (!match || match[2] !== namespace) {
-      optimized.push(command)
-      continue
-    }
-
-    const target = functions.get(match[3])
-    if (!isInlineableFunction(target, currentFn, namespace)) {
-      optimized.push(command)
-      continue
-    }
-
-    optimized.push({ cmd: match[1], label: command.label })
-    optimized.push(...markConditional(target.commands))
-  }
-
-  return optimized
-}
-
-function invertExecuteCondition(command: string): string | null {
-  if (command.startsWith('execute if ')) {
-    return command.replace(/^execute if /, 'execute unless ')
-  }
-  if (command.startsWith('execute unless ')) {
-    return command.replace(/^execute unless /, 'execute if ')
-  }
-  return null
-}
-
-function eliminateBranchVariables(
-  commands: IRCommand[],
-  functions: Map<string, IRFunction>,
-  currentFn: string,
-  namespace: string
-): IRCommand[] {
-  const optimized: IRCommand[] = []
-
-  for (let i = 0; i < commands.length; i++) {
-    const init = commands[i]
-    const set = commands[i + 1]
-    const thenCmd = commands[i + 2]
-    const elseCmd = commands[i + 3]
-
-    const initMatch = init?.cmd.match(/^scoreboard players set (\$[A-Za-z0-9_]+) rs 0$/)
-    const setMatch = set?.cmd.match(/^((?:execute if|execute unless) .+) run scoreboard players set (\$[A-Za-z0-9_]+) rs 1$/)
-    const thenMatch = thenCmd?.cmd.match(/^execute if score (\$[A-Za-z0-9_]+) rs matches 1\.\. run function [^:]+:(.+)$/)
-    const elseMatch =
-      elseCmd?.cmd.match(/^execute if score (\$[A-Za-z0-9_]+) rs matches ..0 run function [^:]+:(.+)$/) ??
-      elseCmd?.cmd.match(/^execute unless score (\$[A-Za-z0-9_]+) rs matches 1\.\. run function [^:]+:(.+)$/)
-
-    if (!initMatch || !setMatch || !thenMatch || !elseMatch) {
-      optimized.push(init)
-      continue
-    }
-
-    const branchVar = initMatch[1]
-    if (setMatch[2] !== branchVar || thenMatch[1] !== branchVar || elseMatch[1] !== branchVar) {
-      optimized.push(init)
-      continue
-    }
-
-    const thenFn = functions.get(thenMatch[2])
-    const elseFn = functions.get(elseMatch[2])
-    if (!isInlineableFunction(thenFn, currentFn, namespace) || !isInlineableFunction(elseFn, currentFn, namespace)) {
-      optimized.push(init)
-      continue
-    }
-
-    const thenCondition = setMatch[1]
-    const elseCondition = invertExecuteCondition(thenCondition)
-    if (!elseCondition) {
-      optimized.push(init)
-      continue
-    }
-
-    optimized.push({ cmd: thenCondition })
-    optimized.push(...markConditional(thenFn.commands))
-    if (elseFn.commands.length > 0) {
-      optimized.push({ cmd: elseCondition })
-      optimized.push(...markConditional(elseFn.commands))
-    }
-    i += 3
-  }
-
-  return optimized
-}
-
-export function optimizeFunctionForStructure(
-  fn: IRFunction,
-  functions: Map<string, IRFunction>,
-  namespace: string
-): IRCommand[] {
-  if (fn.blocks.length === 0) {
-    return []
-  }
-
-  const linear = flattenBlock(fn, fn.blocks[0].label, namespace, new Set<string>())
-  const branchEliminated = eliminateBranchVariables(linear, functions, fn.name, namespace)
-  const inlined = inlineConditionalCalls(branchEliminated, functions, fn.name, namespace)
-  return deadStoreEliminate(inlined)
-}
-
-export function optimizeForStructure(functions: IRFunction[], namespace = 'redscript'): IRFunction[] {
-  return optimizeForStructureWithStats(functions, namespace).functions
-}
-
-export function optimizeForStructureWithStats(
-  functions: IRFunction[],
-  namespace = 'redscript'
-): { functions: IRFunction[]; stats: OptimizationStats } {
-  const staged = new Map(functions.map(fn => [fn.name, { ...fn }]))
-
-  for (const fn of staged.values()) {
-    fn.commands = flattenBlock(fn, fn.blocks[0]?.label ?? 'entry', namespace, new Set<string>())
-  }
-
-  for (const fn of staged.values()) {
-    fn.commands = optimizeFunctionForStructure(fn, staged, namespace)
-  }
-
-  const optimizedCommands = optimizeCommandFunctions(
-    Array.from(staged.values()).map(fn => ({
-      name: fn.name,
-      commands: fn.commands ?? [],
-    }))
-  )
-  const stats = createEmptyOptimizationStats()
-  mergeOptimizationStats(stats, optimizedCommands.stats)
-
-  return {
-    functions: Array.from(staged.values()).map(fn => ({
-      ...fn,
-      commands: optimizedCommands.functions.find(candidate => candidate.name === fn.name)?.commands ?? fn.commands,
-    })),
-    stats,
-  }
-}