redscript-mc 1.2.30 → 2.0.0

package/src2/optimizer/copy_prop.ts

@@ -0,0 +1,106 @@
+/**
+ * Copy Propagation — MIR optimization pass.
+ *
+ * Within each block, tracks `copy dst, src` and `const dst, value` instructions
+ * and replaces subsequent uses of `dst` with the known operand.
+ * Invalidates mappings when a temp is redefined (written to).
+ */
+
+import type { MIRFunction, MIRBlock, MIRInstr, Operand, Temp } from '../mir/types'
+
+export function copyProp(fn: MIRFunction): MIRFunction {
+  return {
+    ...fn,
+    blocks: fn.blocks.map(propBlock),
+  }
+}
+
+function propBlock(block: MIRBlock): MIRBlock {
+  // Map from temp → the operand it was copied from
+  const copies = new Map<Temp, Operand>()
+
+  const instrs: MIRInstr[] = []
+  for (const instr of block.instrs) {
+    // Rewrite uses first
+    const rewritten = rewriteUses(instr, copies)
+
+    // Invalidate any mapping whose source was just redefined
+    const dst = getDst(rewritten)
+    if (dst) {
+      // Remove any mapping that points TO this dst (as a temp source)
+      for (const [k, v] of copies) {
+        if (v.kind === 'temp' && v.name === dst) {
+          copies.delete(k)
+        }
+      }
+      // Remove dst's own previous mapping (will be re-added below if applicable)
+      copies.delete(dst)
+    }
+
+    // Track new propagatable definitions
+    if (rewritten.kind === 'const') {
+      // const dst, value → record dst → const operand
+      copies.set(rewritten.dst, { kind: 'const', value: rewritten.value })
+    } else if (rewritten.kind === 'copy') {
+      // copy dst, src → record dst → src (temp or const)
+      copies.set(rewritten.dst, rewritten.src)
+    }
+
+    instrs.push(rewritten)
+  }
+
+  // Also rewrite terminator uses
+  const term = rewriteUses(block.term, copies)
+
+  return { ...block, instrs, term }
+}
+
+function resolve(op: Operand, copies: Map<Temp, Operand>): Operand {
+  if (op.kind === 'temp') {
+    const replacement = copies.get(op.name)
+    if (replacement) return replacement
+  }
+  return op
+}
+
+function rewriteUses(instr: MIRInstr, copies: Map<Temp, Operand>): MIRInstr {
+  switch (instr.kind) {
+    case 'copy':
+      return { ...instr, src: resolve(instr.src, copies) }
+    case 'neg':
+    case 'not':
+      return { ...instr, src: resolve(instr.src, copies) }
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'and': case 'or':
+      return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) }
+    case 'cmp':
+      return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) }
+    case 'nbt_write':
+      return { ...instr, src: resolve(instr.src, copies) }
+    case 'call':
+      return { ...instr, args: instr.args.map(a => resolve(a, copies)) }
+    case 'call_macro':
+      return { ...instr, args: instr.args.map(a => ({ ...a, value: resolve(a.value, copies) })) }
+    case 'branch':
+      return { ...instr, cond: resolve(instr.cond, copies) }
+    case 'return':
+      return { ...instr, value: instr.value ? resolve(instr.value, copies) : null }
+    default:
+      return instr
+  }
+}
+
+function getDst(instr: MIRInstr): Temp | null {
+  switch (instr.kind) {
+    case 'const': case 'copy':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'neg': case 'cmp':
+    case 'and': case 'or': case 'not':
+    case 'nbt_read':
+      return instr.dst
+    case 'call': case 'call_macro':
+      return instr.dst
+    default:
+      return null
+  }
+}

package/src2/optimizer/dce.ts

@@ -0,0 +1,133 @@
+/**
+ * Dead Code Elimination — MIR optimization pass.
+ *
+ * 1. Removes definitions of temps that are never used anywhere in the function.
+ * 2. Removes unreachable blocks (no predecessors and not the entry block).
+ */
+
+import type { MIRFunction, MIRBlock, MIRInstr, Operand, Temp, BlockId } from '../mir/types'
+
+export function dce(fn: MIRFunction): MIRFunction {
+  // Phase 1: Remove unreachable blocks
+  let blocks = removeUnreachable(fn)
+
+  // Phase 2: Remove unused temp definitions
+  blocks = removeDeadDefs(fn.params, blocks)
+
+  // Phase 3: Recompute preds after block removal
+  blocks = recomputePreds(blocks)
+
+  return { ...fn, blocks }
+}
+
+function removeUnreachable(fn: MIRFunction): MIRBlock[] {
+  const reachable = new Set<BlockId>()
+  const queue: BlockId[] = [fn.entry]
+  const blockMap = new Map(fn.blocks.map(b => [b.id, b]))
+
+  while (queue.length > 0) {
+    const id = queue.shift()!
+    if (reachable.has(id)) continue
+    reachable.add(id)
+    const block = blockMap.get(id)
+    if (block) {
+      for (const target of getTermTargets(block.term)) {
+        if (!reachable.has(target)) queue.push(target)
+      }
+    }
+  }
+
+  return fn.blocks.filter(b => reachable.has(b.id))
+}
+
+function removeDeadDefs(params: { name: Temp }[], blocks: MIRBlock[]): MIRBlock[] {
+  // Collect all used temps across the entire function
+  const used = new Set<Temp>()
+  for (const block of blocks) {
+    for (const instr of block.instrs) {
+      for (const t of getUsedTemps(instr)) used.add(t)
+    }
+    for (const t of getUsedTemps(block.term)) used.add(t)
+  }
+
+  // Remove instructions whose dst is never used, unless they have side effects
+  return blocks.map(block => ({
+    ...block,
+    instrs: block.instrs.filter(instr => {
+      const dst = getDst(instr)
+      if (dst === null) return true  // no dst → keep (side-effectful)
+      if (hasSideEffects(instr)) return true
+      return used.has(dst)
+    }),
+  }))
+}
+
+function recomputePreds(blocks: MIRBlock[]): MIRBlock[] {
+  const predMap = new Map<BlockId, BlockId[]>()
+  for (const b of blocks) predMap.set(b.id, [])
+
+  for (const block of blocks) {
+    for (const target of getTermTargets(block.term)) {
+      const preds = predMap.get(target)
+      if (preds) preds.push(block.id)
+    }
+  }
+
+  return blocks.map(b => ({ ...b, preds: predMap.get(b.id) ?? [] }))
+}
+
+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
+  const dst = getDst(instr)
+  if (dst && dst.startsWith('__rf_')) return true
+  return false
+}
+
+function getTermTargets(term: MIRInstr): BlockId[] {
+  switch (term.kind) {
+    case 'jump': return [term.target]
+    case 'branch': return [term.then, term.else]
+    default: return []
+  }
+}
+
+function getDst(instr: MIRInstr): Temp | null {
+  switch (instr.kind) {
+    case 'const': case 'copy':
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'neg': case 'cmp':
+    case 'and': case 'or': case 'not':
+    case 'nbt_read':
+      return instr.dst
+    case 'call': case 'call_macro':
+      return instr.dst
+    default:
+      return null
+  }
+}
+
+function getUsedTemps(instr: MIRInstr): Temp[] {
+  const temps: Temp[] = []
+  const addOp = (op: Operand) => { if (op.kind === 'temp') temps.push(op.name) }
+
+  switch (instr.kind) {
+    case 'copy': case 'neg': case 'not':
+      addOp(instr.src); break
+    case 'add': case 'sub': case 'mul': case 'div': case 'mod':
+    case 'cmp': case 'and': case 'or':
+      addOp(instr.a); addOp(instr.b); break
+    case 'nbt_write':
+      addOp(instr.src); break
+    case 'call':
+      instr.args.forEach(addOp); break
+    case 'call_macro':
+      instr.args.forEach(a => addOp(a.value)); break
+    case 'branch':
+      addOp(instr.cond); break
+    case 'return':
+      if (instr.value) addOp(instr.value); break
+  }
+  return temps
+}

package/src2/optimizer/pipeline.ts

@@ -0,0 +1,44 @@
+/**
+ * MIR Optimization Pipeline — runs all passes to a fixpoint.
+ *
+ * Each pass is a function MIRFunction → MIRFunction.
+ * The pipeline iterates until no pass changes the function (fixpoint).
+ */
+
+import type { MIRFunction, MIRModule } from '../mir/types'
+import { constantFold } from './constant_fold'
+import { copyProp } from './copy_prop'
+import { dce } from './dce'
+import { blockMerge } from './block_merge'
+import { branchSimplify } from './branch_simplify'
+
+export type Pass = (fn: MIRFunction) => MIRFunction
+
+const defaultPasses: Pass[] = [
+  constantFold,
+  copyProp,
+  branchSimplify,
+  dce,
+  blockMerge,
+]
+
+const MAX_ITERATIONS = 20
+
+export function optimizeFunction(fn: MIRFunction, passes: Pass[] = defaultPasses): MIRFunction {
+  let current = fn
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const before = JSON.stringify(current)
+    for (const pass of passes) {
+      current = pass(current)
+    }
+    if (JSON.stringify(current) === before) break
+  }
+  return current
+}
+
+export function optimizeModule(mod: MIRModule, passes?: Pass[]): MIRModule {
+  return {
+    ...mod,
+    functions: mod.functions.map(fn => optimizeFunction(fn, passes)),
+  }
+}

package/tsconfig.json

@@ -4,13 +4,13 @@
     "module": "commonjs",
     "lib": ["ES2021"],
     "outDir": "dist",
-    "rootDir": "src",
+    "rootDir": ".",
     "declaration": true,
     "sourceMap": true,
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true
   },
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "src2/**/*"],
   "exclude": ["dist", "node_modules"]
 }

package/src/__tests__/codegen.test.ts

@@ -1,161 +0,0 @@
-import { generateDatapack, generateDatapackWithStats } from '../codegen/mcfunction'
-import type { IRModule } from '../ir/types'
-
-describe('generateDatapack', () => {
-  it('generates pack.mcmeta', () => {
-    const mod: IRModule = { namespace: 'test', functions: [], globals: [] }
-    const files = generateDatapack(mod)
-    const meta = files.find(f => f.path === 'pack.mcmeta')
-    expect(meta).toBeDefined()
-    expect(JSON.parse(meta!.content).pack.pack_format).toBe(26)
-  })
-
-  it('generates __load.mcfunction with objective setup', () => {
-    const mod: IRModule = { namespace: 'mypack', functions: [], globals: [{ name: 'counter', init: 0 }] }
-    const files = generateDatapack(mod)
-    const load = files.find(f => f.path.includes('__load.mcfunction'))
-    expect(load?.content).toContain('scoreboard objectives add rs dummy')
-    expect(load?.content).toContain('scoreboard players set $counter rs 0')
-  })
-
-  it('generates function file for simple add(a, b)', () => {
-    // IR now uses { kind: 'param', index: i } for param-copy instructions,
-    // matching what the lowering emits.  Pass mangle:false so we can check
-    // readable names without worrying about sequential mangled names.
-    const mod: IRModule = {
-      namespace: 'mypack',
-      globals: [],
-      functions: [{
-        name: 'add',
-        params: ['$a', '$b'],
-        locals: ['$a', '$b', '$result'],
-        blocks: [{
-          label: 'entry',
-          instrs: [
-            // param-copy instructions (what the lowering now emits)
-            { op: 'assign', dst: '$a', src: { kind: 'param', index: 0 } },
-            { op: 'assign', dst: '$b', src: { kind: 'param', index: 1 } },
-            { op: 'binop', dst: '$result', lhs: { kind: 'var', name: '$a' }, bop: '+', rhs: { kind: 'var', name: '$b' } },
-          ],
-          term: { op: 'return', value: { kind: 'var', name: '$result' } },
-        }],
-      }],
-    }
-    const files = generateDatapackWithStats(mod, { mangle: false }).files
-    const fn = files.find(f => f.path.includes('add.mcfunction'))
-    expect(fn).toBeDefined()
-    // param setup emitted from the IR
-    expect(fn!.content).toContain('scoreboard players operation $a rs = $p0 rs')
-    expect(fn!.content).toContain('scoreboard players operation $b rs = $p1 rs')
-    // Should have add operation
-    expect(fn!.content).toContain('+=')
-  })
-
-  it('generates tick tag for tick loop function', () => {
-    const mod: IRModule = {
-      namespace: 'mypack',
-      globals: [],
-      functions: [{
-        name: 'game_loop',
-        params: [],
-        locals: [],
-        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
-        isTickLoop: true,
-      }],
-    }
-    const files = generateDatapack(mod)
-    
-    // tick.json should point to __tick
-    const tickTag = files.find(f => f.path.includes('tick.json'))
-    expect(tickTag).toBeDefined()
-    expect(JSON.parse(tickTag!.content).values).toContain('mypack:__tick')
-    
-    // __tick.mcfunction should call the game_loop function
-    const tickFn = files.find(f => f.path.includes('__tick.mcfunction'))
-    expect(tickFn).toBeDefined()
-    expect(tickFn!.content).toContain('function mypack:game_loop')
-  })
-
-  it('generates conditional branches with execute if/unless', () => {
-    const mod: IRModule = {
-      namespace: 'mypack',
-      globals: [],
-      functions: [{
-        name: 'check',
-        params: [],
-        locals: ['cond'],
-        blocks: [
-          {
-            label: 'entry',
-            instrs: [
-              { op: 'assign', dst: 'cond', src: { kind: 'const', value: 1 } },
-            ],
-            term: { op: 'jump_if', cond: 'cond', then: 'then_block', else_: 'else_block' },
-          },
-          {
-            label: 'then_block',
-            instrs: [{ op: 'raw', cmd: 'say hello' }],
-            term: { op: 'return' },
-          },
-          {
-            label: 'else_block',
-            instrs: [{ op: 'raw', cmd: 'say goodbye' }],
-            term: { op: 'return' },
-          },
-        ],
-      }],
-    }
-    const files = generateDatapack(mod)
-    const entry = files.find(f => f.path.endsWith('check.mcfunction'))
-    expect(entry?.content).toContain('execute if score $cond rs matches 1..')
-    expect(entry?.content).toContain('execute if score $cond rs matches ..0')
-  })
-
-  it('generates advancement json for event decorators', () => {
-    const mod: IRModule = {
-      namespace: 'mypack',
-      globals: [],
-      functions: [{
-        name: 'on_mine_diamond',
-        params: [],
-        locals: [],
-        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
-        eventTrigger: { kind: 'advancement', value: 'story/mine_diamond' },
-      }],
-    }
-
-    const result = generateDatapackWithStats(mod)
-    const advancement = result.advancements.find(f => f.path === 'data/mypack/advancements/on_advancement_on_mine_diamond.json')
-    expect(advancement).toBeDefined()
-    const json = JSON.parse(advancement!.content)
-    expect(json.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond')
-    expect(json.rewards.function).toBe('mypack:on_mine_diamond')
-  })
-
-  it('generates static event dispatcher in __tick', () => {
-    const mod: IRModule = {
-      namespace: 'mypack',
-      globals: [],
-      functions: [{
-        name: 'handle_death',
-        params: [],
-        locals: [],
-        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
-        eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
-      }, {
-        name: 'handle_death_2',
-        params: [],
-        locals: [],
-        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
-        eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
-      }],
-    }
-
-    const files = generateDatapack(mod)
-    const tickFn = files.find(f => f.path.includes('__tick.mcfunction'))
-    expect(tickFn).toBeDefined()
-    expect(tickFn!.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death')
-    expect(tickFn!.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death_2')
-    expect(tickFn!.content).toContain('tag @a[tag=rs.just_died] remove rs.just_died')
-  })
-})