redscript-mc 2.0.0 → 2.1.1

package/dist/src/optimizer/dce.js

@@ -1,639 +1,156 @@
 "use strict";
+/**
+ * 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).
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeadCodeEliminator = void 0;
-exports.eliminateDeadCode = eliminateDeadCode;
-function copySpan(target, source) {
-    const descriptor = Object.getOwnPropertyDescriptor(source, 'span');
-    if (descriptor) {
-        Object.defineProperty(target, 'span', descriptor);
-    }
-    return target;
+exports.dce = dce;
+function dce(fn) {
+    // 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 isConstantBoolean(expr) {
-    if (expr.kind === 'bool_lit') {
-        return expr.value;
-    }
-    return null;
+function removeUnreachable(fn) {
+    const reachable = new Set();
+    const queue = [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 isPureExpr(expr) {
-    switch (expr.kind) {
-        case 'int_lit':
-        case 'float_lit':
-        case 'byte_lit':
-        case 'short_lit':
-        case 'long_lit':
-        case 'double_lit':
-        case 'rel_coord':
-        case 'local_coord':
-        case 'bool_lit':
-        case 'str_lit':
-        case 'mc_name':
-        case 'range_lit':
-        case 'selector':
-        case 'ident':
-        case 'blockpos':
-            return true;
-        case 'str_interp':
-            return expr.parts.every(part => typeof part === 'string' || isPureExpr(part));
-        case 'f_string':
-            return expr.parts.every(part => part.kind === 'text' || isPureExpr(part.expr));
-        case 'binary':
-            return isPureExpr(expr.left) && isPureExpr(expr.right);
-        case 'is_check':
-            return isPureExpr(expr.expr);
-        case 'unary':
-            return isPureExpr(expr.operand);
-        case 'member':
-            return isPureExpr(expr.obj);
-        case 'index':
-            return isPureExpr(expr.obj) && isPureExpr(expr.index);
-        case 'array_lit':
-            return expr.elements.every(isPureExpr);
-        case 'struct_lit':
-            return expr.fields.every(field => isPureExpr(field.value));
-        case 'lambda':
-            return true;
-        case 'assign':
-        case 'member_assign':
-        case 'call':
-        case 'invoke':
-        case 'static_call':
-            return false;
-    }
+function removeDeadDefs(params, blocks) {
+    // Collect all used temps across the entire function
+    const used = new Set();
+    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);
+        }),
+    }));
 }
-class DeadCodeEliminator {
-    constructor() {
-        this.functionMap = new Map();
-        this.reachableFunctions = new Set();
-        this.usedConstants = new Set();
-        this.localReads = new Set();
-        this.localDeclIds = new WeakMap();
-        this.localIdCounter = 0;
-        this.warnings = [];
-    }
-    eliminate(program) {
-        this.functionMap.clear();
-        this.reachableFunctions.clear();
-        this.usedConstants.clear();
-        this.localReads.clear();
-        this.localIdCounter = 0;
-        this.warnings.length = 0;
-        for (const fn of program.declarations) {
-            this.functionMap.set(fn.name, fn);
-        }
-        const entryPoints = this.findEntryPoints(program);
-        if (entryPoints.length === 0) {
-            for (const fn of program.declarations) {
-                this.markReachable(fn.name);
-            }
-        }
-        else {
-            for (const fnName of entryPoints) {
-                this.markReachable(fnName);
-            }
-        }
-        for (const global of program.globals) {
-            this.collectExprRefs(global.init, []);
-        }
-        for (const implBlock of program.implBlocks) {
-            for (const method of implBlock.methods) {
-                this.collectFunctionRefs(method);
-            }
-        }
-        return {
-            ...program,
-            declarations: program.declarations
-                .filter(fn => this.reachableFunctions.has(fn.name))
-                .map(fn => this.transformFunction(fn)),
-            consts: program.consts.filter(constDecl => this.usedConstants.has(constDecl.name)),
-            implBlocks: program.implBlocks.map(implBlock => ({
-                ...implBlock,
-                methods: implBlock.methods.map(method => this.transformFunction(method)),
-            })),
-        };
-    }
-    findEntryPoints(program) {
-        const entries = new Set();
-        for (const fn of program.declarations) {
-            // Library functions (from `module library;` or `librarySources`) are
-            // NOT MC entry points — they're only kept if reachable from user code.
-            // Exception: decorators like @tick / @load / @on / @keep always force inclusion.
-            if (!fn.isLibraryFn) {
-                // All top-level non-library functions are entry points (callable via /function)
-                // Exception: functions starting with _ are considered private/internal
-                if (!fn.name.startsWith('_')) {
-                    entries.add(fn.name);
-                }
-            }
-            // Decorated functions are always entry points regardless of library mode or _ prefix
-            if (fn.decorators.some(decorator => [
-                'tick',
-                'load',
-                'on',
-                'on_trigger',
-                'on_advancement',
-                'on_craft',
-                'on_death',
-                'on_login',
-                'on_join_team',
-                'keep',
-            ].includes(decorator.name))) {
-                entries.add(fn.name);
-            }
-        }
-        return [...entries];
-    }
-    markReachable(fnName) {
-        if (this.reachableFunctions.has(fnName)) {
-            return;
-        }
-        const fn = this.functionMap.get(fnName);
-        if (!fn) {
-            return;
-        }
-        this.reachableFunctions.add(fnName);
-        this.collectFunctionRefs(fn);
-        // @requires("dep") — when fn is reachable, its required dependencies are
-        // also pulled into the reachable set so they survive DCE.
-        for (const decorator of fn.decorators) {
-            if (decorator.name === 'require_on_load') {
-                for (const arg of decorator.rawArgs ?? []) {
-                    if (arg.kind === 'string') {
-                        this.markReachable(arg.value);
-                    }
-                }
-            }
-        }
-    }
-    collectFunctionRefs(fn) {
-        const scope = [fn.params.map(param => ({ id: `param:${fn.name}:${param.name}`, name: param.name }))];
-        for (const param of fn.params) {
-            if (param.default) {
-                this.collectExprRefs(param.default, scope);
-            }
-        }
-        this.collectStmtRefs(fn.body, scope);
-    }
-    collectStmtRefs(block, scope) {
-        scope.push([]);
-        for (const stmt of block) {
-            this.collectStmtRef(stmt, scope);
-        }
-        scope.pop();
-    }
-    collectStmtRef(stmt, scope) {
-        switch (stmt.kind) {
-            case 'let': {
-                this.collectExprRefs(stmt.init, scope);
-                const id = `local:${stmt.name}:${this.localIdCounter++}:${(stmt.span?.line ?? 0)}:${(stmt.span?.col ?? 0)}`;
-                this.localDeclIds.set(stmt, id);
-                scope[scope.length - 1].push({ id, name: stmt.name });
-                break;
-            }
-            case 'expr':
-                this.collectExprRefs(stmt.expr, scope);
-                break;
-            case 'return':
-                if (stmt.value) {
-                    this.collectExprRefs(stmt.value, scope);
-                }
-                break;
-            case 'if': {
-                this.collectExprRefs(stmt.cond, scope);
-                const constant = isConstantBoolean(stmt.cond);
-                if (constant === true) {
-                    this.collectStmtRefs(stmt.then, scope);
-                }
-                else if (constant === false) {
-                    if (stmt.else_) {
-                        this.collectStmtRefs(stmt.else_, scope);
-                    }
-                }
-                else {
-                    this.collectStmtRefs(stmt.then, scope);
-                    if (stmt.else_) {
-                        this.collectStmtRefs(stmt.else_, scope);
-                    }
-                }
-                break;
-            }
-            case 'while':
-                this.collectExprRefs(stmt.cond, scope);
-                this.collectStmtRefs(stmt.body, scope);
-                break;
-            case 'for':
-                scope.push([]);
-                if (stmt.init) {
-                    this.collectStmtRef(stmt.init, scope);
-                }
-                this.collectExprRefs(stmt.cond, scope);
-                this.collectExprRefs(stmt.step, scope);
-                this.collectStmtRefs(stmt.body, scope);
-                scope.pop();
-                break;
-            case 'foreach':
-                this.collectExprRefs(stmt.iterable, scope);
-                scope.push([{ id: `foreach:${stmt.binding}:${stmt.span?.line ?? 0}:${stmt.span?.col ?? 0}`, name: stmt.binding }]);
-                this.collectStmtRefs(stmt.body, scope);
-                scope.pop();
-                break;
-            case 'for_range':
-                this.collectExprRefs(stmt.start, scope);
-                this.collectExprRefs(stmt.end, scope);
-                scope.push([{ id: `range:${stmt.varName}:${stmt.span?.line ?? 0}:${stmt.span?.col ?? 0}`, name: stmt.varName }]);
-                this.collectStmtRefs(stmt.body, scope);
-                scope.pop();
-                break;
-            case 'match':
-                this.collectExprRefs(stmt.expr, scope);
-                for (const arm of stmt.arms) {
-                    if (arm.pattern) {
-                        this.collectExprRefs(arm.pattern, scope);
-                    }
-                    this.collectStmtRefs(arm.body, scope);
-                }
-                break;
-            case 'as_block':
-            case 'at_block':
-            case 'as_at':
-            case 'execute':
-                this.collectNestedStmtRefs(stmt, scope);
-                break;
-            case 'raw':
-            case 'break':
-            case 'continue':
-                break;
-        }
-    }
-    collectNestedStmtRefs(stmt, scope) {
-        if (stmt.kind === 'execute') {
-            for (const sub of stmt.subcommands) {
-                if ('varName' in sub && sub.varName) {
-                    const resolved = this.resolveLocal(sub.varName, scope);
-                    if (resolved) {
-                        this.localReads.add(resolved.id);
-                    }
-                }
-            }
-        }
-        this.collectStmtRefs(stmt.body, scope);
-    }
-    collectExprRefs(expr, scope) {
-        switch (expr.kind) {
-            case 'ident': {
-                const resolved = this.resolveLocal(expr.name, scope);
-                if (resolved) {
-                    this.localReads.add(resolved.id);
-                }
-                else {
-                    this.usedConstants.add(expr.name);
-                }
-                break;
-            }
-            case 'call':
-                {
-                    const resolved = this.resolveLocal(expr.fn, scope);
-                    if (resolved) {
-                        this.localReads.add(resolved.id);
-                    }
-                    else if (this.functionMap.has(expr.fn)) {
-                        this.markReachable(expr.fn);
-                    }
-                }
-                for (const arg of expr.args) {
-                    this.collectExprRefs(arg, scope);
-                }
-                break;
-            case 'static_call':
-                for (const arg of expr.args) {
-                    this.collectExprRefs(arg, scope);
-                }
-                break;
-            case 'invoke':
-                this.collectExprRefs(expr.callee, scope);
-                for (const arg of expr.args) {
-                    this.collectExprRefs(arg, scope);
-                }
-                break;
-            case 'member':
-                this.collectExprRefs(expr.obj, scope);
-                break;
-            case 'member_assign':
-                this.collectExprRefs(expr.obj, scope);
-                this.collectExprRefs(expr.value, scope);
-                break;
-            case 'index':
-                this.collectExprRefs(expr.obj, scope);
-                this.collectExprRefs(expr.index, scope);
-                break;
-            case 'array_lit':
-                expr.elements.forEach(element => this.collectExprRefs(element, scope));
-                break;
-            case 'struct_lit':
-                expr.fields.forEach(field => this.collectExprRefs(field.value, scope));
-                break;
-            case 'binary':
-                this.collectExprRefs(expr.left, scope);
-                this.collectExprRefs(expr.right, scope);
-                break;
-            case 'is_check':
-                this.collectExprRefs(expr.expr, scope);
-                break;
-            case 'unary':
-                this.collectExprRefs(expr.operand, scope);
-                break;
-            case 'assign': {
-                this.collectExprRefs(expr.value, scope);
-                break;
-            }
-            case 'str_interp':
-                expr.parts.forEach(part => {
-                    if (typeof part !== 'string') {
-                        this.collectExprRefs(part, scope);
-                    }
-                });
-                break;
-            case 'f_string':
-                expr.parts.forEach(part => {
-                    if (part.kind === 'expr') {
-                        this.collectExprRefs(part.expr, scope);
-                    }
-                });
-                break;
-            case 'lambda': {
-                const lambdaScope = [
-                    ...scope.map(entries => [...entries]),
-                    expr.params.map(param => ({ id: `lambda:${param.name}:${expr.span?.line ?? 0}:${expr.span?.col ?? 0}`, name: param.name })),
-                ];
-                if (Array.isArray(expr.body)) {
-                    this.collectStmtRefs(expr.body, lambdaScope);
-                }
-                else {
-                    this.collectExprRefs(expr.body, lambdaScope);
-                }
-                break;
-            }
-            case 'blockpos':
-            case 'bool_lit':
-            case 'byte_lit':
-            case 'double_lit':
-            case 'float_lit':
-            case 'int_lit':
-            case 'long_lit':
-            case 'mc_name':
-            case 'range_lit':
-            case 'selector':
-            case 'short_lit':
-            case 'str_lit':
-                break;
-        }
-    }
-    resolveLocal(name, scope) {
-        for (let i = scope.length - 1; i >= 0; i--) {
-            for (let j = scope[i].length - 1; j >= 0; j--) {
-                if (scope[i][j].name === name) {
-                    return scope[i][j];
-                }
-            }
-        }
-        return null;
-    }
-    transformFunction(fn) {
-        const scope = [fn.params.map(param => ({ id: `param:${fn.name}:${param.name}`, name: param.name }))];
-        const body = this.transformBlock(fn.body, scope);
-        return body === fn.body ? fn : copySpan({ ...fn, body }, fn);
-    }
-    transformBlock(block, scope) {
-        scope.push([]);
-        const transformed = [];
-        for (const stmt of block) {
-            const next = this.transformStmt(stmt, scope);
-            transformed.push(...next);
-        }
-        scope.pop();
-        return transformed;
-    }
-    transformStmt(stmt, scope) {
-        switch (stmt.kind) {
-            case 'let': {
-                const init = this.transformExpr(stmt.init, scope);
-                const id = this.localDeclIds.get(stmt) ?? `local:${stmt.name}:${stmt.span?.line ?? 0}:${stmt.span?.col ?? 0}`;
-                scope[scope.length - 1].push({ id, name: stmt.name });
-                if (this.localReads.has(id)) {
-                    if (init === stmt.init) {
-                        return [stmt];
-                    }
-                    return [copySpan({ ...stmt, init }, stmt)];
-                }
-                // Unused variable - emit warning
-                this.warnings.push({
-                    message: `Unused variable '${stmt.name}'`,
-                    code: 'W_UNUSED_VAR',
-                    line: stmt.span?.line,
-                    col: stmt.span?.col,
-                });
-                if (isPureExpr(init)) {
-                    return [];
-                }
-                return [copySpan({ kind: 'expr', expr: init }, stmt)];
-            }
-            case 'expr': {
-                const expr = this.transformExpr(stmt.expr, scope);
-                if (expr.kind === 'assign') {
-                    const resolved = this.resolveLocal(expr.target, scope);
-                    if (resolved && !this.localReads.has(resolved.id)) {
-                        if (isPureExpr(expr.value)) {
-                            return [];
-                        }
-                        return [copySpan({ kind: 'expr', expr: expr.value }, stmt)];
-                    }
-                }
-                if (expr === stmt.expr) {
-                    return [stmt];
-                }
-                return [copySpan({ ...stmt, expr }, stmt)];
-            }
-            case 'return': {
-                if (!stmt.value) {
-                    return [stmt];
-                }
-                const value = this.transformExpr(stmt.value, scope);
-                if (value === stmt.value) {
-                    return [stmt];
-                }
-                return [copySpan({ ...stmt, value }, stmt)];
-            }
-            case 'if': {
-                const cond = this.transformExpr(stmt.cond, scope);
-                const constant = isConstantBoolean(cond);
-                if (constant === true) {
-                    return this.transformBlock(stmt.then, scope);
-                }
-                if (constant === false) {
-                    return stmt.else_ ? this.transformBlock(stmt.else_, scope) : [];
-                }
-                const thenBlock = this.transformBlock(stmt.then, scope);
-                const elseBlock = stmt.else_ ? this.transformBlock(stmt.else_, scope) : undefined;
-                if (cond === stmt.cond && thenBlock === stmt.then && elseBlock === stmt.else_) {
-                    return [stmt];
-                }
-                return [copySpan({ ...stmt, cond, then: thenBlock, else_: elseBlock }, stmt)];
-            }
-            case 'while': {
-                const cond = this.transformExpr(stmt.cond, scope);
-                if (isConstantBoolean(cond) === false) {
-                    return [];
-                }
-                const body = this.transformBlock(stmt.body, scope);
-                return [copySpan({ ...stmt, cond, body }, stmt)];
-            }
-            case 'for': {
-                const forScope = [...scope, []];
-                const init = stmt.init ? this.transformStmt(stmt.init, forScope)[0] : undefined;
-                const cond = this.transformExpr(stmt.cond, forScope);
-                if (isConstantBoolean(cond) === false) {
-                    return init ? [init] : [];
-                }
-                const step = this.transformExpr(stmt.step, forScope);
-                const body = this.transformBlock(stmt.body, forScope);
-                return [copySpan({ ...stmt, init, cond, step, body }, stmt)];
-            }
-            case 'foreach': {
-                const iterable = this.transformExpr(stmt.iterable, scope);
-                const foreachScope = [...scope, [{ id: `foreach:${stmt.binding}:${stmt.span?.line ?? 0}:${stmt.span?.col ?? 0}`, name: stmt.binding }]];
-                const body = this.transformBlock(stmt.body, foreachScope);
-                return [copySpan({ ...stmt, iterable, body }, stmt)];
-            }
-            case 'for_range': {
-                const start = this.transformExpr(stmt.start, scope);
-                const end = this.transformExpr(stmt.end, scope);
-                const rangeScope = [...scope, [{ id: `range:${stmt.varName}:${stmt.span?.line ?? 0}:${stmt.span?.col ?? 0}`, name: stmt.varName }]];
-                const body = this.transformBlock(stmt.body, rangeScope);
-                return [copySpan({ ...stmt, start, end, body }, stmt)];
-            }
-            case 'match': {
-                const expr = this.transformExpr(stmt.expr, scope);
-                const arms = stmt.arms.map(arm => ({
-                    pattern: arm.pattern ? this.transformExpr(arm.pattern, scope) : null,
-                    body: this.transformBlock(arm.body, scope),
-                }));
-                return [copySpan({ ...stmt, expr, arms }, stmt)];
-            }
-            case 'as_block':
-                return [copySpan({ ...stmt, body: this.transformBlock(stmt.body, scope) }, stmt)];
-            case 'at_block':
-                return [copySpan({ ...stmt, body: this.transformBlock(stmt.body, scope) }, stmt)];
-            case 'as_at':
-                return [copySpan({ ...stmt, body: this.transformBlock(stmt.body, scope) }, stmt)];
-            case 'execute':
-                return [copySpan({ ...stmt, body: this.transformBlock(stmt.body, scope) }, stmt)];
-            case 'raw':
-                return [stmt];
-            case 'break':
-                return [stmt];
-            case 'continue':
-                return [stmt];
-        }
-    }
-    transformExpr(expr, scope) {
-        switch (expr.kind) {
-            case 'call':
-                return copySpan({ ...expr, args: expr.args.map(arg => this.transformExpr(arg, scope)) }, expr);
-            case 'static_call':
-                return copySpan({ ...expr, args: expr.args.map(arg => this.transformExpr(arg, scope)) }, expr);
-            case 'invoke':
-                return copySpan({
-                    ...expr,
-                    callee: this.transformExpr(expr.callee, scope),
-                    args: expr.args.map(arg => this.transformExpr(arg, scope)),
-                }, expr);
-            case 'binary':
-                return copySpan({
-                    ...expr,
-                    left: this.transformExpr(expr.left, scope),
-                    right: this.transformExpr(expr.right, scope),
-                }, expr);
-            case 'is_check':
-                return copySpan({ ...expr, expr: this.transformExpr(expr.expr, scope) }, expr);
-            case 'unary':
-                return copySpan({ ...expr, operand: this.transformExpr(expr.operand, scope) }, expr);
-            case 'assign':
-                return copySpan({ ...expr, value: this.transformExpr(expr.value, scope) }, expr);
-            case 'member':
-                return copySpan({ ...expr, obj: this.transformExpr(expr.obj, scope) }, expr);
-            case 'member_assign':
-                return copySpan({
-                    ...expr,
-                    obj: this.transformExpr(expr.obj, scope),
-                    value: this.transformExpr(expr.value, scope),
-                }, expr);
-            case 'index':
-                return copySpan({
-                    ...expr,
-                    obj: this.transformExpr(expr.obj, scope),
-                    index: this.transformExpr(expr.index, scope),
-                }, expr);
-            case 'array_lit':
-                return copySpan({ ...expr, elements: expr.elements.map(element => this.transformExpr(element, scope)) }, expr);
-            case 'struct_lit':
-                return copySpan({
-                    ...expr,
-                    fields: expr.fields.map(field => ({ ...field, value: this.transformExpr(field.value, scope) })),
-                }, expr);
-            case 'str_interp':
-                return copySpan({
-                    ...expr,
-                    parts: expr.parts.map(part => typeof part === 'string' ? part : this.transformExpr(part, scope)),
-                }, expr);
-            case 'f_string':
-                return copySpan({
-                    ...expr,
-                    parts: expr.parts.map(part => part.kind === 'text' ? part : { kind: 'expr', expr: this.transformExpr(part.expr, scope) }),
-                }, expr);
-            case 'lambda': {
-                const lambdaScope = [
-                    ...scope.map(entries => [...entries]),
-                    expr.params.map(param => ({ id: `lambda:${param.name}:${expr.span?.line ?? 0}:${expr.span?.col ?? 0}`, name: param.name })),
-                ];
-                const body = Array.isArray(expr.body)
-                    ? this.transformBlock(expr.body, lambdaScope)
-                    : this.transformExpr(expr.body, lambdaScope);
-                return copySpan({ ...expr, body }, expr);
-            }
-            case 'blockpos':
-            case 'bool_lit':
-            case 'byte_lit':
-            case 'double_lit':
-            case 'float_lit':
-            case 'ident':
-            case 'int_lit':
-            case 'long_lit':
-            case 'mc_name':
-            case 'range_lit':
-            case 'rel_coord':
-            case 'local_coord':
-            case 'selector':
-            case 'short_lit':
-            case 'str_lit':
-                return expr;
-        }
+function recomputePreds(blocks) {
+    const predMap = new Map();
+    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) {
+    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_') || dst.startsWith('__opt_')))
+        return true;
+    return false;
+}
+function getTermTargets(term) {
+    switch (term.kind) {
+        case 'jump': return [term.target];
+        case 'branch': return [term.then, term.else];
+        default: return [];
     }
 }
-exports.DeadCodeEliminator = DeadCodeEliminator;
-function eliminateDeadCode(program, sourceRanges) {
-    const eliminator = new DeadCodeEliminator();
-    const result = eliminator.eliminate(program);
-    let warnings = eliminator.warnings;
-    // Resolve combined-source line numbers back to original file + line
-    if (sourceRanges && sourceRanges.length > 0) {
-        const { resolveSourceLine } = require('../compile');
-        warnings = warnings.map(w => {
-            if (w.line == null)
-                return w;
-            const resolved = resolveSourceLine(w.line, sourceRanges);
-            return { ...w, line: resolved.line, filePath: resolved.filePath ?? w.filePath };
-        });
+function getDst(instr) {
+    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;
     }
-    return { program: result, warnings };
+}
+function getUsedTemps(instr) {
+    const temps = [];
+    const addOp = (op) => { 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;
 }
 //# sourceMappingURL=dce.js.map