redscript-mc 1.0.0

package/dist/optimizer/commands.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptyOptimizationStats = createEmptyOptimizationStats;
+exports.mergeOptimizationStats = mergeOptimizationStats;
+exports.applyLICM = applyLICM;
+exports.applyCSE = applyCSE;
+exports.batchSetblocks = batchSetblocks;
+exports.optimizeCommandFunctions = optimizeCommandFunctions;
+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+)$/;
+function createEmptyOptimizationStats() {
+    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) {
+    return { ...command };
+}
+function cloneFunctions(functions) {
+    return functions.map(fn => ({
+        name: fn.name,
+        commands: fn.commands.map(cloneCommand),
+    }));
+}
+function mergeOptimizationStats(base, delta) {
+    for (const [key, value] of Object.entries(delta)) {
+        base[key] += value;
+    }
+}
+function parseScoreboardWrite(command) {
+    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, from, to) {
+    const re = new RegExp(`\\${from}(?![A-Za-z0-9_])`, 'g');
+    return command.replace(re, to);
+}
+function collectObjectiveWrites(functions) {
+    const writes = new Map();
+    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) {
+    const stats = { 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 = [];
+        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();
+            const scoreboardWrites = new Set();
+            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 = [];
+            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, index) {
+    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) {
+    const stats = { cseRedundantReads: 0, cseArithmetic: 0 };
+    for (const fn of functions) {
+        const commands = fn.commands.map(cloneCommand);
+        const readCache = new Map();
+        const exprCache = new Map();
+        const rewritten = [];
+        function invalidateByTemp(temp) {
+            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) {
+    const rewritten = [];
+    const stats = {
+        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 = 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) {
+    const stats = {
+        setblockMergedCommands: 0,
+        setblockFillCommands: 0,
+        setblockSavedCommands: 0,
+    };
+    for (const fn of functions) {
+        const batched = batchSetblocksInCommands(fn.commands);
+        fn.commands = batched.commands;
+        mergeOptimizationStats(stats, batched.stats);
+    }
+    return stats;
+}
+function applyLICM(functions) {
+    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 };
+}
+function applyCSE(functions) {
+    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 };
+}
+function batchSetblocks(functions) {
+    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 };
+}
+function optimizeCommandFunctions(functions) {
+    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,
+    };
+}
+//# sourceMappingURL=commands.js.map

package/dist/optimizer/passes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { IRFunction } from '../ir/types';
+import { type OptimizationStats } from './commands';
+export declare function constantFolding(fn: IRFunction): IRFunction;
+export declare function constantFoldingWithStats(fn: IRFunction): {
+    fn: IRFunction;
+    stats: Partial<OptimizationStats>;
+};
+export declare function copyPropagation(fn: IRFunction): IRFunction;
+export declare function deadCodeElimination(fn: IRFunction): IRFunction;
+export declare function deadCodeEliminationWithStats(fn: IRFunction): {
+    fn: IRFunction;
+    stats: Partial<OptimizationStats>;
+};
+export interface OptimizationPass {
+    name: string;
+    run: (fn: IRFunction) => IRFunction;
+}
+export declare const defaultPipeline: OptimizationPass[];
+export declare function optimize(fn: IRFunction, passes?: OptimizationPass[]): IRFunction;
+export declare function optimizeWithStats(fn: IRFunction, passes?: OptimizationPass[]): {
+    fn: IRFunction;
+    stats: OptimizationStats;
+};

package/dist/optimizer/passes.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPipeline = void 0;
+exports.constantFolding = constantFolding;
+exports.constantFoldingWithStats = constantFoldingWithStats;
+exports.copyPropagation = copyPropagation;
+exports.deadCodeElimination = deadCodeElimination;
+exports.deadCodeEliminationWithStats = deadCodeEliminationWithStats;
+exports.optimize = optimize;
+exports.optimizeWithStats = optimizeWithStats;
+const commands_1 = require("./commands");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isConst(op) {
+    return op.kind === 'const';
+}
+function evalBinop(lhs, bop, rhs) {
+    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, cop, rhs) {
+    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.
+// ---------------------------------------------------------------------------
+function constantFolding(fn) {
+    return constantFoldingWithStats(fn).fn;
+}
+function constantFoldingWithStats(fn) {
+    let folded = 0;
+    const newBlocks = fn.blocks.map(block => {
+        const newInstrs = [];
+        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
+// ---------------------------------------------------------------------------
+function copyPropagation(fn) {
+    // Build copy map within each block (single-block analysis for simplicity)
+    const newBlocks = fn.blocks.map(block => {
+        const copies = new Map(); // var → its source if it's a copy
+        function resolve(op) {
+            if (op.kind !== 'var')
+                return op;
+            return copies.get(op.name) ?? op;
+        }
+        const newInstrs = [];
+        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.
+// ---------------------------------------------------------------------------
+function deadCodeElimination(fn) {
+    return deadCodeEliminationWithStats(fn).fn;
+}
+function deadCodeEliminationWithStats(fn) {
+    // Collect all reads across all blocks
+    const readVars = new Set();
+    function markRead(op) {
+        if (op.kind === 'var')
+            readVars.add(op.name);
+    }
+    function markRawReads(cmd) {
+        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 } };
+}
+exports.defaultPipeline = [
+    { name: 'constant-folding', run: constantFolding },
+    { name: 'copy-propagation', run: copyPropagation },
+    { name: 'dead-code-elimination', run: deadCodeElimination },
+    // commandMerging is applied during codegen (MC-specific)
+];
+function optimize(fn, passes = exports.defaultPipeline) {
+    return optimizeWithStats(fn, passes).fn;
+}
+function optimizeWithStats(fn, passes = exports.defaultPipeline) {
+    let current = fn;
+    const stats = (0, commands_1.createEmptyOptimizationStats)();
+    for (const pass of passes) {
+        if (pass.name === 'constant-folding') {
+            const result = constantFoldingWithStats(current);
+            current = result.fn;
+            (0, commands_1.mergeOptimizationStats)(stats, result.stats);
+            continue;
+        }
+        if (pass.name === 'dead-code-elimination') {
+            const result = deadCodeEliminationWithStats(current);
+            current = result.fn;
+            (0, commands_1.mergeOptimizationStats)(stats, result.stats);
+            continue;
+        }
+        current = pass.run(current);
+    }
+    return { fn: current, stats };
+}
+//# sourceMappingURL=passes.js.map

package/dist/optimizer/structure.d.ts

@@ -0,0 +1,8 @@
+import type { IRCommand, IRFunction } from '../ir/types';
+import { type OptimizationStats } from './commands';
+export declare function optimizeFunctionForStructure(fn: IRFunction, functions: Map<string, IRFunction>, namespace: string): IRCommand[];
+export declare function optimizeForStructure(functions: IRFunction[], namespace?: string): IRFunction[];
+export declare function optimizeForStructureWithStats(functions: IRFunction[], namespace?: string): {
+    functions: IRFunction[];
+    stats: OptimizationStats;
+};