storm-lua-minify 0.3.0 → 0.9.1

package/dist/removeUnused.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUnusedLocals = removeUnusedLocals;
+function rangeOf(node) {
+    return node.range;
+}
+function nestedBodies(statement) {
+    switch (statement.type) {
+        case "DoStatement":
+        case "WhileStatement":
+        case "RepeatStatement":
+        case "FunctionDeclaration":
+        case "ForNumericStatement":
+        case "ForGenericStatement":
+            return [statement.body];
+        case "IfStatement":
+            return statement.clauses.map((clause) => clause.body);
+        default:
+            return [];
+    }
+}
+function isStatementCall(expression) {
+    return (expression.type === "CallExpression" ||
+        expression.type === "TableCallExpression" ||
+        expression.type === "StringCallExpression");
+}
+function callStatement(expression) {
+    return {
+        type: "CallStatement",
+        expression,
+        loc: expression.loc,
+        range: rangeOf(expression),
+    };
+}
+function hasExternalReference(statement, references) {
+    const range = rangeOf(statement);
+    if (!range)
+        return references.length > 0;
+    return references.some((reference) => {
+        const position = rangeOf(reference)?.[0];
+        return (position === undefined || position < range[0] || position >= range[1]);
+    });
+}
+function removeFromBlock(body, resolved, metadata, facts, onRemoveLocalFunction, options = { removeLocals: true, removeFunctions: true }) {
+    let changed = false;
+    body.forEach((statement) => {
+        nestedBodies(statement).forEach((nested) => {
+            changed =
+                removeFromBlock(nested, resolved, metadata, facts, onRemoveLocalFunction, options) || changed;
+        });
+    });
+    const replacements = new Map();
+    body.forEach((statement) => {
+        if (metadata.annotationsOf(statement).keep)
+            return;
+        if (options.removeFunctions &&
+            statement.type === "FunctionDeclaration" &&
+            statement.isLocal &&
+            statement.identifier?.type === "Identifier") {
+            const symbol = resolved.symbolOf(statement.identifier);
+            if (symbol && !hasExternalReference(statement, symbol.references)) {
+                onRemoveLocalFunction?.(statement);
+                changed = true;
+                replacements.set(statement, []);
+                return;
+            }
+        }
+        if (!options.removeLocals || statement.type !== "LocalStatement")
+            return;
+        const unused = statement.variables.map((variable) => {
+            const symbol = resolved.symbolOf(variable);
+            return Boolean(symbol && symbol.references.length === 0);
+        });
+        if (!unused.some(Boolean))
+            return;
+        if (unused.every(Boolean)) {
+            if (statement.init.every((expression) => facts.discardabilityOf(expression).discardable ||
+                isStatementCall(expression))) {
+                const calls = statement.init.filter(isStatementCall).map(callStatement);
+                changed = true;
+                replacements.set(statement, calls);
+            }
+            return;
+        }
+        let variables = [...statement.variables];
+        let init = [...statement.init];
+        let unusedAfterPairRemoval = [...unused];
+        // 初期値なしなら全変数の値はnilで固定され、位置対応を維持する必要がない。
+        if (init.length === 0) {
+            variables = variables.filter((_, index) => !unused[index]);
+            unusedAfterPairRemoval = unused.filter((value) => !value);
+        }
+        // 要素数が一致するときだけ、変数とRHSの対応を崩さず安全なペアを抜ける。
+        if (init.length > 0 && variables.length === init.length) {
+            const retainedIndexes = variables
+                .map((_, index) => index)
+                .filter((index) => !(unused[index] && facts.discardabilityOf(init[index]).discardable));
+            variables = retainedIndexes.map((index) => variables[index]);
+            init = retainedIndexes.map((index) => init[index]);
+            unusedAfterPairRemoval = retainedIndexes.map((index) => unused[index]);
+        }
+        // 末尾の未使用名は、対応RHSを余剰式として評価させたまま名前だけ除ける。
+        let retainedVariableCount = variables.length;
+        while (retainedVariableCount > 0 &&
+            unusedAfterPairRemoval[retainedVariableCount - 1]) {
+            retainedVariableCount--;
+        }
+        variables = variables.slice(0, retainedVariableCount);
+        if (variables.length === statement.variables.length)
+            return;
+        changed = true;
+        const replacement = {
+            ...statement,
+            variables,
+            init,
+        };
+        replacements.set(statement, [replacement]);
+    });
+    if (replacements.size > 0) {
+        const nextBody = [];
+        body.forEach((statement, index) => {
+            const replacement = replacements.get(statement);
+            if (!replacement) {
+                nextBody.push(statement);
+                return;
+            }
+            if (replacement.length > 0) {
+                metadata.replaceStatement(statement, replacement);
+                nextBody.push(...replacement);
+                return;
+            }
+            const next = body.slice(index + 1).find((candidate) => {
+                const candidateReplacement = replacements.get(candidate);
+                return !candidateReplacement || candidateReplacement.length > 0;
+            });
+            const nextReplacement = next ? replacements.get(next) : undefined;
+            metadata.removeStatement(statement, nextReplacement?.[0] ?? next);
+        });
+        body.splice(0, body.length, ...nextBody);
+    }
+    return changed;
+}
+function removeUnusedLocals(chunk, resolved, metadata, facts, onRemoveLocalFunction, options) {
+    return removeFromBlock(chunk.body, resolved, metadata, facts, onRemoveLocalFunction, options);
+}

package/dist/renamer.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAvailable = isAvailable;
 exports.generateCandidate = generateCandidate;
 exports.assignRenames = assignRenames;
+const resolver_1 = require("./resolver");
 const ast2lua_1 = require("./ast2lua");
+const controlFlow_1 = require("./controlFlow");
+const optimizerFacts_1 = require("./optimizerFacts");
+const symbolLiveness_1 = require("./symbolLiveness");
 function isAvailable(id, reserved) {
     return id !== "self" && !(0, ast2lua_1.isKeyword)(id) && !reserved.has(id);
 }
@@ -21,62 +25,33 @@ function generateCandidate(counter) {
     }
     return id;
 }
-/**
- * スコープ木のDFSでシンボルごとにスロット番号を割り当てる。
- * `active`は祖先スコープ（自分を含む）で既に使われているスロットの集合。
- * 兄弟スコープには同じ`active`のコピーが渡されるため、互いの割当は影響しない。
- */
-function assignSlots(scope, active) {
-    const slotOf = new Map();
-    const used = new Set(active);
-    scope.symbols.forEach((symbol) => {
-        let slot = 0;
-        while (used.has(slot)) {
-            slot++;
-        }
-        slotOf.set(symbol, slot);
-        used.add(slot);
-    });
-    scope.children.forEach((child) => {
-        assignSlots(child, used).forEach((slot, symbol) => {
-            slotOf.set(symbol, slot);
-        });
-    });
-    return slotOf;
-}
-function assignRenames(resolveResult, reserved, 
+function assignRenames(chunk, resolveResult, reserved, 
 // #8a: プログラム全体を横断して決定されたグローバル識別子の短縮名。
 // 全モジュールに対して同じマップを渡すことで、モジュールをまたいで
 // 共有される1つのランタイム束縛に一貫した短縮名を割り当てられる。
-globalRenames) {
-    const slotOf = assignSlots(resolveResult.chunkScope, new Set());
-    // スロットの通算参照回数（宣言自体も1回として数える）を集計する。
-    const weightOfSlot = new Map();
-    resolveResult.symbols.forEach((symbol) => {
-        const slot = slotOf.get(symbol);
-        if (slot === undefined) {
-            return;
-        }
-        const weight = symbol.references.length + 1;
-        weightOfSlot.set(slot, (weightOfSlot.get(slot) ?? 0) + weight);
-    });
-    const orderedSlots = [...weightOfSlot.keys()].sort((a, b) => (weightOfSlot.get(b) ?? 0) - (weightOfSlot.get(a) ?? 0));
-    const nameOfSlot = new Map();
-    let counter = 0;
-    orderedSlots.forEach((slot) => {
-        let candidate;
-        do {
-            candidate = generateCandidate(counter++);
-        } while (!isAvailable(candidate, reserved));
-        nameOfSlot.set(slot, candidate);
-    });
-    const nameOfSymbol = new Map();
-    slotOf.forEach((slot, symbol) => {
-        const name = nameOfSlot.get(slot);
-        if (name !== undefined) {
-            nameOfSymbol.set(symbol, name);
-        }
-    });
+globalRenames, keepNames = new Set(), options = {}) {
+    const unavailableNames = new Set(reserved);
+    keepNames.forEach((symbol) => unavailableNames.add(symbol.name));
+    const variables = options.renameLocals === false
+        ? []
+        : resolveResult.symbols.filter((symbol) => symbol.kind !== "label" &&
+            !symbol.implicit &&
+            !keepNames.has(symbol));
+    const variableGraph = buildVariableInterference(chunk, resolveResult, variables, options.allowLocalNameReuse === true, options.analysis);
+    const variableColors = colorGraph(variableGraph);
+    const variableNames = assignColorNames(variableColors, unavailableNames);
+    // Labels have a separate Lua namespace. Color them independently so a label
+    // and a local may share a short spelling, while usedNames still reserves the
+    // spelling against labels from subsequently spliced modules.
+    const labels = options.renameLocals === false
+        ? []
+        : resolveResult.symbols.filter((symbol) => symbol.kind === "label" &&
+            symbol.name !== "self" &&
+            !keepNames.has(symbol));
+    const labelNames = assignColorNames(colorGraph(buildLexicalGraph(labels, false)), unavailableNames);
+    const nameOfSymbol = new Map([...variableNames, ...labelNames]);
+    validateBindings(chunk, resolveResult, nameOfSymbol, globalRenames);
+    const usedNames = new Set(nameOfSymbol.values());
     return {
         nameOf: (identifier) => {
             // メソッド定義の暗黙のselfパラメータは慣習的な名前のため常に維持する
@@ -96,6 +71,257 @@ globalRenames) {
             }
             return undefined;
         },
-        usedNames: new Set(nameOfSlot.values()),
+        usedNames,
     };
 }
+function buildVariableInterference(chunk, resolved, symbols, allowLocalNameReuse, analysis) {
+    const graph = mutableGraph(symbols);
+    const facts = analysis?.facts ?? (0, optimizerFacts_1.analyzeOptimizerFacts)(chunk, resolved);
+    const liveness = analysis?.liveness ??
+        (0, symbolLiveness_1.analyzeSymbolLiveness)((0, controlFlow_1.analyzeControlFlow)(chunk, resolved), facts);
+    if (facts.generation !== liveness.controlFlow.version)
+        throw new Error("Identifier coloring requires one AST generation");
+    liveness.controlFlow.nodes.forEach((node) => {
+        addClique(graph, liveness.liveIn(node));
+        addClique(graph, liveness.liveOut(node));
+        liveness.defs(node).forEach((definition) => {
+            liveness.liveOut(node).forEach((live) => {
+                addEdge(graph, definition, live);
+            });
+        });
+    });
+    // Parameters, generic-for variables, and multi-local declarations bind as a
+    // group. Giving two members one spelling would make only the last binding
+    // addressable after reparsing even if one member happens to be unused.
+    const declarationsByOwner = new Map();
+    symbols.forEach((symbol) => {
+        const declaration = facts
+            .operationsOfSymbol(symbol)
+            .find((operation) => operation.kind === "declare" &&
+            operation.origin === symbol.declaration);
+        if (!declaration)
+            return;
+        const group = declarationsByOwner.get(declaration.owner) ?? [];
+        group.push(symbol);
+        declarationsByOwner.set(declaration.owner, group);
+    });
+    declarationsByOwner.forEach((group) => {
+        addClique(graph, group);
+    });
+    // A captured binding can be shadowed inside the closure by any same-scope
+    // declaration whose emitted spelling matches it (notably `local function`).
+    // Extending this lexical interference across the whole declaring scope is
+    // conservative, deterministic, and leaves ordinary non-captured locals free
+    // to reuse names according to liveness.
+    symbols.forEach((symbol) => {
+        const captured = facts
+            .operationsOfSymbol(symbol)
+            .some((operation) => "location" in operation && operation.location.kind === "upvalue");
+        if (!captured)
+            return;
+        symbols.forEach((other) => {
+            if (other.scope === symbol.scope)
+                addEdge(graph, symbol, other);
+        });
+    });
+    // Liveness alone does not model Lua's lexical shadowing. An earlier local
+    // may be dead at a later declaration and then be assigned again; if both
+    // declarations receive one spelling, the later declaration captures that
+    // assignment and every following reference. Preserve reuse when all uses of
+    // the earlier binding precede the later declaration, but add an edge when
+    // any use follows it.
+    const declarationOrder = new Map(symbols.map((symbol) => [
+        symbol,
+        requireResolutionOrder(resolved, symbol.declaration),
+    ]));
+    const lastReferenceOrder = new Map(symbols.map((symbol) => [
+        symbol,
+        symbol.references.reduce((last, reference) => Math.max(last, requireResolutionOrder(resolved, reference)), -1),
+    ]));
+    for (let left = 0; left < symbols.length; left++) {
+        for (let right = left + 1; right < symbols.length; right++) {
+            const first = symbols[left];
+            const last = symbols[right];
+            if (first.scope !== last.scope)
+                continue;
+            const firstDeclarationOrder = declarationOrder.get(first) ?? -1;
+            const lastDeclarationOrder = declarationOrder.get(last) ?? -1;
+            const [earlier, laterDeclarationOrder] = firstDeclarationOrder < lastDeclarationOrder
+                ? [first, lastDeclarationOrder]
+                : [last, firstDeclarationOrder];
+            if ((lastReferenceOrder.get(earlier) ?? -1) > laterDeclarationOrder)
+                addEdge(graph, first, last);
+        }
+    }
+    addLexicalEdges(graph, symbols, allowLocalNameReuse);
+    return graph;
+}
+function requireResolutionOrder(resolved, identifier) {
+    const order = resolved.resolutionOrderOf(identifier);
+    if (order === undefined)
+        throw new Error("Resolved identifier has no resolution order");
+    return order;
+}
+function buildLexicalGraph(symbols, allowSameScopeReuse) {
+    const graph = mutableGraph(symbols);
+    addLexicalEdges(graph, symbols, allowSameScopeReuse);
+    return graph;
+}
+function mutableGraph(symbols) {
+    return new Map(symbols.map((symbol) => [symbol, new Set()]));
+}
+function addLexicalEdges(graph, symbols, allowSameScopeReuse) {
+    for (let left = 0; left < symbols.length; left++) {
+        for (let right = left + 1; right < symbols.length; right++) {
+            const first = symbols[left];
+            const last = symbols[right];
+            if (isAncestor(first.scope, last.scope) ||
+                isAncestor(last.scope, first.scope) ||
+                (!allowSameScopeReuse && first.scope === last.scope))
+                addEdge(graph, first, last);
+        }
+    }
+}
+function isAncestor(ancestor, descendant) {
+    if (ancestor === descendant)
+        return false;
+    for (let current = descendant.parent; current; current = current.parent)
+        if (current === ancestor)
+            return true;
+    return false;
+}
+function addClique(graph, symbols) {
+    const present = [...symbols].filter((symbol) => graph.has(symbol));
+    for (let left = 0; left < present.length; left++)
+        for (let right = left + 1; right < present.length; right++)
+            addEdge(graph, present[left], present[right]);
+}
+function addEdge(graph, first, last) {
+    if (first === last || !graph.has(first) || !graph.has(last))
+        return;
+    graph.get(first)?.add(last);
+    graph.get(last)?.add(first);
+}
+/** Deterministic weighted DSATUR coloring. */
+function colorGraph(graph) {
+    const colors = new Map();
+    // Keep the colored-neighbor set incrementally. Recomputing it inside the
+    // sort comparator makes dense module graphs dominate the whole pipeline.
+    const saturationColors = new Map([...graph.keys()].map((symbol) => [symbol, new Set()]));
+    while (colors.size < graph.size) {
+        let symbol;
+        graph.forEach((_neighbors, candidate) => {
+            if (colors.has(candidate))
+                return;
+            if (symbol === undefined ||
+                coloringPriority(candidate, symbol, graph, saturationColors) < 0)
+                symbol = candidate;
+        });
+        if (symbol === undefined)
+            throw new Error("Uncolored symbol not found");
+        const unavailable = saturationColors.get(symbol) ?? new Set();
+        let color = 0;
+        while (unavailable.has(color))
+            color++;
+        colors.set(symbol, color);
+        graph.get(symbol)?.forEach((neighbor) => {
+            if (!colors.has(neighbor))
+                saturationColors.get(neighbor)?.add(color);
+        });
+    }
+    return colors;
+}
+function coloringPriority(left, right, graph, saturationColors) {
+    const saturationDifference = (saturationColors.get(right)?.size ?? 0) -
+        (saturationColors.get(left)?.size ?? 0);
+    if (saturationDifference !== 0)
+        return saturationDifference;
+    const weightDifference = weightOf(right) - weightOf(left);
+    if (weightDifference !== 0)
+        return weightDifference;
+    const degreeDifference = (graph.get(right)?.size ?? 0) - (graph.get(left)?.size ?? 0);
+    return degreeDifference !== 0 ? degreeDifference : left.id - right.id;
+}
+function weightOf(symbol) {
+    return symbol.references.length + 1;
+}
+function assignColorNames(colors, reserved) {
+    const unavailable = new Set(reserved);
+    const weightByColor = new Map();
+    const firstSymbolByColor = new Map();
+    colors.forEach((color, symbol) => {
+        weightByColor.set(color, (weightByColor.get(color) ?? 0) + weightOf(symbol));
+        firstSymbolByColor.set(color, Math.min(firstSymbolByColor.get(color) ?? symbol.id, symbol.id));
+    });
+    const orderedColors = [...weightByColor.keys()].sort((left, right) => (weightByColor.get(right) ?? 0) - (weightByColor.get(left) ?? 0) ||
+        (firstSymbolByColor.get(left) ?? 0) -
+            (firstSymbolByColor.get(right) ?? 0));
+    const nameByColor = new Map();
+    let counter = 0;
+    orderedColors.forEach((color) => {
+        let candidate;
+        do
+            candidate = generateCandidate(counter++);
+        while (!isAvailable(candidate, unavailable));
+        unavailable.add(candidate);
+        nameByColor.set(color, candidate);
+    });
+    // Every candidate is an identifier token and keywords are excluded, so the
+    // separator cost around each occurrence is invariant across candidates.
+    // Occurrence count therefore gives the exact candidate-dependent byte cost.
+    const result = new Map();
+    colors.forEach((color, symbol) => {
+        const name = nameByColor.get(color);
+        if (name === undefined)
+            throw new Error("Colored symbol has no name");
+        result.set(symbol, name);
+    });
+    return result;
+}
+function validateBindings(chunk, original, names, globalRenames) {
+    const recolored = (0, resolver_1.resolveScopes)(chunk, {
+        identifierName: (identifier) => {
+            const symbol = original.symbolOf(identifier);
+            if (symbol)
+                return names.get(symbol) ?? identifier.name;
+            return original.isGlobalReference(identifier)
+                ? (globalRenames?.get(identifier.name) ?? identifier.name)
+                : identifier.name;
+        },
+    });
+    original.symbols.forEach((symbol) => {
+        if (symbol.implicit) {
+            symbol.references.forEach((identifier) => {
+                const rebound = recolored.symbolOf(identifier);
+                if (!rebound?.implicit || rebound.name !== symbol.name)
+                    throw new Error(`Identifier coloring changed implicit binding for symbol ${String(symbol.id)}`);
+            });
+            return;
+        }
+        [symbol.declaration, ...symbol.references].forEach((identifier) => {
+            const rebound = recolored.symbolOf(identifier);
+            if (rebound?.declaration !== symbol.declaration) {
+                const reboundOriginal = rebound
+                    ? original.symbolOf(rebound.declaration)
+                    : undefined;
+                throw new Error(`Identifier coloring changed binding for symbol ${String(symbol.id)} ` +
+                    `(${symbol.name} -> ${names.get(symbol) ?? symbol.name}, ` +
+                    `declaration ${formatIdentifierLocation(symbol.declaration)}, ` +
+                    `reference ${formatIdentifierLocation(identifier)}, ` +
+                    `rebound to ${reboundOriginal ? `symbol ${String(reboundOriginal.id)} (${reboundOriginal.name} -> ${names.get(reboundOriginal) ?? reboundOriginal.name}) at ${formatIdentifierLocation(reboundOriginal.declaration)}` : "global"})`);
+            }
+        });
+    });
+    original.globals.forEach((binding) => {
+        binding.references.forEach((identifier) => {
+            if (!recolored.isGlobalReference(identifier))
+                throw new Error(`Identifier coloring captured global ${binding.name}`);
+        });
+    });
+}
+function formatIdentifierLocation(identifier) {
+    const location = identifier.loc?.start;
+    return location
+        ? `${String(location.line)}:${String(location.column)}`
+        : "unknown";
+}

package/dist/resolver.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveScopes = resolveScopes;
-function resolveScopes(chunk) {
+function resolveScopes(chunk, options = {}) {
     let nextSymbolId = 0;
     const allSymbols = [];
     const globals = new Map();
     const identifierSymbols = new WeakMap();
+    const identifierResolutionOrders = new WeakMap();
+    let nextResolutionOrder = 0;
     const globalReferenceNodes = new WeakSet();
+    const functionScopes = new WeakMap();
+    const identifierName = options.identifierName ??
+        ((identifier) => identifier.name);
     function createScope(kind, parent) {
         const scope = {
             kind,
@@ -19,33 +24,38 @@ function resolveScopes(chunk) {
         parent?.children.push(scope);
         return scope;
     }
-    function declare(scope, node, kind) {
+    function declare(scope, node, kind, implicit = false) {
+        identifierResolutionOrders.set(node, nextResolutionOrder++);
+        const name = identifierName(node);
         const symbol = {
             id: nextSymbolId++,
-            name: node.name,
+            name,
             kind,
             scope,
             declaration: node,
             references: [],
+            ...(implicit ? { implicit: true } : {}),
         };
         // 同名の再宣言はスコープ内の以後の参照から見た束縛を上書きする（Luaの通常のシャドーイング）
         scope.symbols.push(symbol);
-        scope.bindings.set(node.name, symbol);
+        scope.bindings.set(name, symbol);
         allSymbols.push(symbol);
         identifierSymbols.set(node, symbol);
         return symbol;
     }
     function declareLabel(scope, node) {
+        identifierResolutionOrders.set(node, nextResolutionOrder++);
+        const name = identifierName(node);
         const symbol = {
             id: nextSymbolId++,
-            name: node.name,
+            name,
             kind: "label",
             scope,
             declaration: node,
             references: [],
         };
         scope.symbols.push(symbol);
-        scope.labels.set(node.name, symbol);
+        scope.labels.set(name, symbol);
         allSymbols.push(symbol);
         identifierSymbols.set(node, symbol);
         return symbol;
@@ -69,16 +79,18 @@ function resolveScopes(chunk) {
         return undefined;
     }
     function reference(scope, node, isWrite = false) {
-        const symbol = lookupBinding(scope, node.name);
+        identifierResolutionOrders.set(node, nextResolutionOrder++);
+        const name = identifierName(node);
+        const symbol = lookupBinding(scope, name);
         if (symbol) {
             symbol.references.push(node);
             identifierSymbols.set(node, symbol);
             return;
         }
-        let binding = globals.get(node.name);
+        let binding = globals.get(name);
         if (!binding) {
-            binding = { name: node.name, references: [], writes: [] };
-            globals.set(node.name, binding);
+            binding = { name, references: [], writes: [] };
+            globals.set(name, binding);
         }
         binding.references.push(node);
         if (isWrite) {
@@ -188,7 +200,8 @@ function resolveScopes(chunk) {
                 // hoistLabelsで宣言済みのため、ここでは何もしない
                 return;
             case "GotoStatement": {
-                const symbol = lookupLabel(scope, statement.label.name);
+                identifierResolutionOrders.set(statement.label, nextResolutionOrder++);
+                const symbol = lookupLabel(scope, identifierName(statement.label));
                 if (symbol) {
                     symbol.references.push(statement.label);
                     identifierSymbols.set(statement.label, symbol);
@@ -218,6 +231,14 @@ function resolveScopes(chunk) {
             }
         }
         const inner = createScope("function", scope);
+        functionScopes.set(fn, inner);
+        if (fn.identifier?.type === "MemberExpression" &&
+            fn.identifier.indexer === ":") {
+            // `function object:method(...)` declares an implicit first parameter. It has no
+            // declaration token in the AST, but it must still own every `self` reference so
+            // global analysis, aliases, summaries, and binding validation share Lua's binding.
+            declare(inner, { type: "Identifier", name: "self" }, "param", true);
+        }
         fn.parameters.forEach((parameter) => {
             if (parameter.type === "Identifier") {
                 declare(inner, parameter, "param");
@@ -268,6 +289,7 @@ function resolveScopes(chunk) {
                 return;
             case "FunctionDeclaration": {
                 const inner = createScope("function", scope);
+                functionScopes.set(expr, inner);
                 expr.parameters.forEach((parameter) => {
                     if (parameter.type === "Identifier") {
                         declare(inner, parameter, "param");
@@ -303,7 +325,9 @@ function resolveScopes(chunk) {
         chunkScope,
         symbols: allSymbols,
         globals,
+        resolutionOrderOf: (identifier) => identifierResolutionOrders.get(identifier),
         symbolOf: (identifier) => identifierSymbols.get(identifier),
         isGlobalReference: (identifier) => globalReferenceNodes.has(identifier),
+        scopeOfFunction: (fn) => functionScopes.get(fn),
     };
 }