storm-lua-minify 0.3.0 → 0.9.0

package/dist/wholeProgramObjects.js

@@ -0,0 +1,783 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeWholeProgramObjects = analyzeWholeProgramObjects;
+const astWalk_1 = require("./astWalk");
+const callGraph_1 = require("./callGraph");
+const linker_1 = require("./linker");
+/**
+ * Build the object/module identity layer once for a linked AST generation.
+ *
+ * This analysis intentionally publishes resolved methods as ordinary CallSite -> Callable
+ * relations. Consumers do not need to know whether a callable came from a lexical alias or
+ * from a factory allocation. Unknown Lua table behaviour invalidates the affected identity;
+ * it never creates a guessed edge.
+ */
+function analyzeWholeProgramObjects(modules, generation) {
+    const moduleByName = new Map(modules.map((module) => [module.name, module]));
+    const moduleOfNode = new WeakMap();
+    const callableModule = new Map();
+    const callableOfDeclaration = new WeakMap();
+    const callSiteOfExpression = new WeakMap();
+    modules.forEach((module) => {
+        walkStatements(module.chunk.body, (node) => moduleOfNode.set(node, module));
+        module.analysis.callGraph.functions.forEach((callable) => {
+            callableModule.set(callable, module);
+            callableOfDeclaration.set(callable.declaration, callable);
+        });
+        module.analysis.callGraph.calls.forEach((call) => callSiteOfExpression.set(call.call, call));
+    });
+    const mutableObjects = [];
+    const objectOfTable = new WeakMap();
+    const valuesOfSymbol = new Map();
+    const valuesOfExpression = new WeakMap();
+    const moduleReturns = new Map();
+    const functionsOfSymbol = new Map();
+    const moduleFunctionReturns = new Map();
+    const methodDefinitions = new WeakSet();
+    const factoryTemplates = new Map();
+    const factoryCopyAssignments = new WeakSet();
+    const constructorTemplates = new Map();
+    const sourcesOfObject = new Map();
+    let nextObject = 0;
+    const objectForTable = (table, module) => {
+        const existing = objectOfTable.get(table);
+        if (existing)
+            return existing;
+        const object = {
+            id: `${module.name}:table:${String(nextObject++)}`,
+            moduleName: module.name,
+            kind: "allocation",
+            methods: new Map(),
+            invalidationReasons: new Set(),
+        };
+        objectOfTable.set(table, object);
+        mutableObjects.push(object);
+        return object;
+    };
+    modules.forEach((module) => {
+        visitExpressions(module.chunk.body, (expression) => {
+            if (expression.type === "TableConstructorExpression")
+                objectForTable(expression, module);
+        });
+    });
+    modules.forEach((module) => {
+        const returned = topLevelReturn(module.chunk);
+        if (!returned)
+            return;
+        let callable;
+        if (returned.type === "FunctionDeclaration")
+            callable = module.analysis.callGraph.functionOf(returned);
+        else if (returned.type === "Identifier") {
+            const symbol = module.resolved.symbolOf(returned);
+            if (symbol)
+                callable = module.analysis.callGraph.functionOfSymbol(symbol);
+        }
+        if (callable)
+            moduleFunctionReturns.set(module.name, new Set([callable]));
+    });
+    const directValues = (expression, module) => {
+        const cached = valuesOfExpression.get(expression);
+        if (cached)
+            return cached;
+        let result = new Set();
+        if (expression.type === "TableConstructorExpression") {
+            result.add(objectForTable(expression, module));
+        }
+        else if (expression.type === "Identifier") {
+            const symbol = module.resolved.symbolOf(expression);
+            if (symbol)
+                result = new Set(valuesOfSymbol.get(symbol) ?? []);
+        }
+        else if (expression.type === "CallExpression") {
+            const required = staticRequiredModule(expression);
+            if (required)
+                result = new Set(moduleReturns.get(required) ?? []);
+        }
+        else if (expression.type === "LogicalExpression") {
+            directValues(expression.left, module).forEach((object) => {
+                result.add(object);
+            });
+            directValues(expression.right, module).forEach((object) => {
+                result.add(object);
+            });
+        }
+        valuesOfExpression.set(expression, result);
+        return result;
+    };
+    // Stable table and require aliases form the seed identity relation.
+    let changed = true;
+    while (changed) {
+        changed = false;
+        modules.forEach((module) => {
+            visitBindings(module.chunk.body, (target, value) => {
+                const symbol = module.resolved.symbolOf(target);
+                if (!symbol || !stableSymbol(symbol, module.analysis))
+                    return;
+                const incoming = directValues(value, module);
+                if (unionInto(valuesOfSymbol, symbol, incoming))
+                    changed = true;
+                if (value.type === "CallExpression") {
+                    const required = staticRequiredModule(value);
+                    if (required &&
+                        unionCallableInto(functionsOfSymbol, symbol, moduleFunctionReturns.get(required) ?? new Set()))
+                        changed = true;
+                }
+            });
+            const returned = topLevelReturn(module.chunk);
+            if (returned) {
+                const incoming = directValues(returned, module);
+                const current = moduleReturns.get(module.name) ?? new Set();
+                const before = current.size;
+                incoming.forEach((object) => {
+                    object.kind = "module-return";
+                    current.add(object);
+                });
+                moduleReturns.set(module.name, current);
+                if (current.size !== before)
+                    changed = true;
+            }
+        });
+        valuesOfExpressionCleanup(valuesOfExpression, modules);
+    }
+    // Member function declarations establish prototype fields by object identity.
+    modules.forEach((module) => {
+        walkStatements(module.chunk.body, (node) => {
+            if (node.type !== "FunctionDeclaration")
+                return;
+            const declaration = node;
+            if (declaration.identifier?.type !== "MemberExpression")
+                return;
+            const callable = callableOfDeclaration.get(declaration);
+            if (!callable)
+                return;
+            const key = declaration.identifier.identifier.name;
+            const bases = directValues(declaration.identifier.base, module);
+            bases.forEach((object) => {
+                object.kind =
+                    object.kind === "module-return" ? object.kind : "prototype";
+                const prior = object.methods.get(key);
+                if (prior && prior !== callable)
+                    object.invalidationReasons.add("method-field-mutation");
+                object.methods.set(key, callable);
+            });
+            if (declaration.identifier.indexer === ":") {
+                const self = callable.parameters[0];
+                if (self.name === "self")
+                    bases.forEach((object) => {
+                        unionInto(valuesOfSymbol, self, new Set([object]));
+                    });
+            }
+            methodDefinitions.add(declaration.identifier);
+        });
+    });
+    modules.forEach((module) => {
+        module.analysis.callGraph.functions.forEach((callable) => {
+            const factory = recognizeMixinFactory(callable, module.resolved);
+            if (factory) {
+                factoryTemplates.set(callable, factory);
+                factory.copyAssignments.forEach((assignment) => factoryCopyAssignments.add(assignment));
+            }
+        });
+        walkStatements(module.chunk.body, (node) => {
+            if (node.type !== "ForGenericStatement")
+                return;
+            recognizeKeyPreservingTransfers(node, module.resolved).forEach((transfer) => {
+                factoryCopyAssignments.add(transfer.assignment);
+                const targets = directValues(transfer.target, module);
+                const sources = directValues(transfer.source, module);
+                targets.forEach((target) => {
+                    const recordedSources = sourcesOfObject.get(target) ?? new Set();
+                    sources.forEach((source) => {
+                        recordedSources.add(source);
+                        source.methods.forEach((callable, key) => target.methods.set(key, callable));
+                    });
+                    sourcesOfObject.set(target, recordedSources);
+                });
+            });
+        });
+    });
+    const directCallTargets = (call, module) => {
+        const targets = new Set(call.targets);
+        const expression = call.call;
+        if (expression.type !== "CallExpression")
+            return targets;
+        if (expression.base.type === "Identifier") {
+            const symbol = module.resolved.symbolOf(expression.base);
+            if (symbol)
+                functionsOfSymbol.get(symbol)?.forEach((target) => targets.add(target));
+        }
+        else if (expression.base.type === "MemberExpression") {
+            const member = expression.base;
+            directValues(member.base, module).forEach((object) => {
+                const target = object.methods.get(member.identifier.name);
+                if (target)
+                    targets.add(target);
+            });
+        }
+        return targets;
+    };
+    modules.forEach((module) => {
+        module.analysis.callGraph.functions.forEach((callable) => {
+            const constructor = recognizeConstructor(callable, module, factoryTemplates, (call) => {
+                const site = callSiteOfExpression.get(call);
+                if (!site)
+                    return new Set();
+                const targets = directCallTargets(site, module);
+                const member = call.base.type === "MemberExpression" ? call.base : undefined;
+                if (member)
+                    directValues(member.base, module).forEach((object) => {
+                        const target = object.methods.get(member.identifier.name);
+                        if (target)
+                            targets.add(target);
+                    });
+                return targets;
+            });
+            if (constructor)
+                constructorTemplates.set(callable, constructor);
+        });
+    });
+    // Constructor calls allocate a distinct identity at each call site. The copied prototype
+    // and a factory-returned base contribute methods to that one identity.
+    const instanceOfCall = new WeakMap();
+    const constructorOfCall = new WeakMap();
+    changed = true;
+    while (changed) {
+        changed = false;
+        modules.forEach((module) => {
+            module.analysis.callGraph.calls.forEach((call) => {
+                if (call.call.type !== "CallExpression")
+                    return;
+                const targets = directCallTargets(call, module);
+                const member = call.call.base.type === "MemberExpression"
+                    ? call.call.base
+                    : undefined;
+                if (member)
+                    directValues(member.base, module).forEach((object) => {
+                        const target = object.methods.get(member.identifier.name);
+                        if (target)
+                            targets.add(target);
+                    });
+                const constructor = [...targets]
+                    .map((target) => constructorTemplates.get(target))
+                    .filter((value) => value !== undefined);
+                const mixin = [...targets]
+                    .map((target) => factoryTemplates.get(target))
+                    .filter((value) => value !== undefined);
+                if (constructor.length + mixin.length !== 1)
+                    return;
+                let instance = instanceOfCall.get(call.call);
+                if (!instance) {
+                    instance = {
+                        id: `${module.name}:call:${String(call.id)}`,
+                        moduleName: module.name,
+                        kind: "allocation",
+                        methods: new Map(),
+                        invalidationReasons: new Set(),
+                    };
+                    instanceOfCall.set(call.call, instance);
+                    mutableObjects.push(instance);
+                    changed = true;
+                }
+                const sources = new Set();
+                if (constructor.length === 1) {
+                    constructorOfCall.set(call.call, constructor[0]);
+                    directValues(constructor[0].prototype, constructor[0].module).forEach((object) => sources.add(object));
+                    directValues(constructor[0].base, constructor[0].module).forEach((object) => sources.add(object));
+                }
+                else {
+                    const args = call.call.arguments;
+                    const base = args.at(0);
+                    const prototype = args.at(1);
+                    if (!base || !prototype)
+                        return;
+                    directValues(base, module).forEach((object) => sources.add(object));
+                    directValues(prototype, module).forEach((object) => sources.add(object));
+                }
+                sources.forEach((source) => {
+                    const recordedSources = sourcesOfObject.get(instance) ?? new Set();
+                    recordedSources.add(source);
+                    sourcesOfObject.set(instance, recordedSources);
+                    source.methods.forEach((target, key) => instance.methods.set(key, target));
+                    source.invalidationReasons.forEach((reason) => instance.invalidationReasons.add(reason));
+                });
+                valuesOfExpression.set(call.call, new Set([instance]));
+            });
+            visitBindings(module.chunk.body, (target, value) => {
+                const symbol = module.resolved.symbolOf(target);
+                if (!symbol || !stableSymbol(symbol, module.analysis))
+                    return;
+                if (unionInto(valuesOfSymbol, symbol, directValues(value, module)))
+                    changed = true;
+            });
+            module.analysis.callGraph.calls.forEach((call) => {
+                const expression = call.call;
+                if (expression.type !== "CallExpression")
+                    return;
+                const targets = directCallTargets(call, module);
+                if (targets.size !== 1)
+                    return;
+                const target = [...targets][0];
+                target.parameters.forEach((parameter, index) => {
+                    const actual = expression.arguments.at(index);
+                    if (actual &&
+                        unionInto(valuesOfSymbol, parameter, directValues(actual, module)))
+                        changed = true;
+                });
+            });
+        });
+        valuesOfExpressionCleanup(valuesOfExpression, modules, true);
+    }
+    // Invalidate only identities that cross an unproved observation/mutation boundary.
+    modules.forEach((module) => {
+        walkStatements(module.chunk.body, (node) => {
+            if (node.type === "AssignmentStatement") {
+                const statement = node;
+                if (factoryCopyAssignments.has(statement))
+                    return;
+                statement.variables.forEach((target) => {
+                    if (target.type === "IndexExpression") {
+                        const key = (0, linker_1.staticStringArgument)(target.index);
+                        if (key === undefined)
+                            directValues(target.base, module).forEach((object) => object.invalidationReasons.add("dynamic-key"));
+                        else
+                            directValues(target.base, module).forEach((object) => {
+                                if (object.methods.has(key))
+                                    object.invalidationReasons.add("method-field-mutation");
+                            });
+                    }
+                    else if (target.type === "MemberExpression") {
+                        if (methodDefinitions.has(target))
+                            return;
+                        directValues(target.base, module).forEach((object) => {
+                            if (object.methods.has(target.identifier.name))
+                                object.invalidationReasons.add("method-field-mutation");
+                        });
+                    }
+                });
+            }
+        });
+        module.analysis.callGraph.calls.forEach((call) => {
+            if (call.call.type !== "CallExpression")
+                return;
+            if (call.call.base.type === "Identifier" &&
+                call.call.base.name === "setmetatable") {
+                directValues(call.call.arguments[0], module).forEach((object) => object.invalidationReasons.add("metatable-mutation"));
+                return;
+            }
+            if (directCallTargets(call, module).size > 0 ||
+                staticRequiredModule(call.call))
+                return;
+            if (call.caller &&
+                factoryTemplates.has(call.caller) &&
+                call.call.base.type === "Identifier" &&
+                (call.call.base.name === "pairs" || call.call.base.name === "type"))
+                return;
+            if (call.call.base.type === "MemberExpression") {
+                const member = call.call.base;
+                const knownFactory = [
+                    ...directValues(call.call.base.base, module),
+                ].some((object) => {
+                    const target = object.methods.get(member.identifier.name);
+                    return target ? factoryTemplates.has(target) : false;
+                });
+                if (knownFactory)
+                    return;
+            }
+            call.call.arguments.forEach((argument) => {
+                directValues(argument, module).forEach((object) => object.invalidationReasons.add(object.kind === "prototype" || object.kind === "module-return"
+                    ? "prototype-escape"
+                    : "instance-escape"));
+            });
+        });
+    });
+    changed = true;
+    while (changed) {
+        changed = false;
+        sourcesOfObject.forEach((sources, object) => {
+            const before = object.invalidationReasons.size;
+            sources.forEach((source) => {
+                source.invalidationReasons.forEach((reason) => object.invalidationReasons.add(reason));
+            });
+            if (object.invalidationReasons.size !== before)
+                changed = true;
+        });
+    }
+    const resolvedMethods = [];
+    const diagnostics = [];
+    modules.forEach((module) => {
+        module.analysis.callGraph.calls.forEach((call) => {
+            if (call.call.type === "CallExpression" &&
+                call.call.base.type === "Identifier" &&
+                call.call.base.name === "require") {
+                const required = staticRequiredModule(call.call);
+                if (!required)
+                    diagnostics.push({
+                        moduleName: module.name,
+                        reason: "dynamic-module-boundary",
+                        ...sourceRangeOf(call.call),
+                    });
+                else if (!moduleByName.has(required))
+                    diagnostics.push({
+                        moduleName: module.name,
+                        reason: "external-module-boundary",
+                        ...sourceRangeOf(call.call),
+                    });
+            }
+            if (call.call.type !== "CallExpression" ||
+                call.call.base.type !== "MemberExpression" ||
+                call.call.base.indexer !== ":")
+                return;
+            const receiver = call.call.base.base;
+            const candidates = [...directValues(receiver, module)];
+            const callerAllocations = candidates.filter((candidate) => candidate.kind === "allocation" &&
+                candidate.moduleName === module.name);
+            // A constructor template contains its own factory call, but each outer call owns the
+            // observable allocation identity. Keep the template allocation as provenance only.
+            const dispatchCandidates = callerAllocations.length > 0 ? callerAllocations : candidates;
+            if (dispatchCandidates.length !== 1) {
+                diagnostics.push({
+                    moduleName: module.name,
+                    reason: dispatchCandidates.length === 0
+                        ? "allocation-unknown"
+                        : "multiple-targets",
+                    ...sourceRangeOf(call.call),
+                });
+                return;
+            }
+            const object = dispatchCandidates[0];
+            if (object.invalidationReasons.size > 0) {
+                object.invalidationReasons.forEach((reason) => diagnostics.push({
+                    moduleName: module.name,
+                    reason,
+                    ...sourceRangeOf(call.call),
+                }));
+                return;
+            }
+            const target = object.methods.get(call.call.base.identifier.name);
+            if (!target)
+                return;
+            const resolved = { call, receiver, target, object };
+            resolvedMethods.push(resolved);
+            diagnostics.push({
+                moduleName: module.name,
+                reason: "resolved-method-target",
+                ...sourceRangeOf(call.call),
+            });
+        });
+    });
+    const publicObjects = mutableObjects.map((object) => ({
+        id: object.id,
+        moduleName: object.moduleName,
+        kind: object.kind,
+        methods: object.methods,
+        invalidationReasons: object.invalidationReasons,
+        sources: [],
+    }));
+    const publicOfMutable = new Map(mutableObjects.map((object, index) => [object, publicObjects[index]]));
+    mutableObjects.forEach((object, index) => {
+        const target = publicObjects[index].sources;
+        sourcesOfObject.get(object)?.forEach((source) => {
+            const publicSource = publicOfMutable.get(source);
+            if (publicSource)
+                target.push(publicSource);
+        });
+    });
+    const resolvedConstructors = [];
+    modules.forEach((module) => {
+        module.analysis.callGraph.calls.forEach((call) => {
+            if (call.call.type !== "CallExpression")
+                return;
+            const template = constructorOfCall.get(call.call);
+            const mutable = instanceOfCall.get(call.call);
+            const object = mutable ? publicOfMutable.get(mutable) : undefined;
+            if (!template || !object)
+                return;
+            resolvedConstructors.push({
+                moduleName: module.name,
+                call,
+                target: template.callable,
+                object,
+                returnedSymbol: template.returnedSymbol,
+                arguments: call.call.arguments,
+            });
+        });
+    });
+    const resolvedPublic = resolvedMethods.map((resolved) => ({
+        ...resolved,
+        object: publicOfMutable.get(resolved.object),
+    }));
+    const methodByCall = new Map(resolvedPublic.map((method) => [method.call, method]));
+    const methodByExpression = new WeakMap(resolvedPublic.map((method) => [method.call.call, method]));
+    const resolvedTargetByCall = new Map(resolvedPublic.map((method) => [method.call, method.target]));
+    modules.forEach((module) => {
+        module.analysis.callGraph.calls.forEach((call) => {
+            if (resolvedTargetByCall.has(call))
+                return;
+            const targets = directCallTargets(call, module);
+            if (targets.size === 1)
+                resolvedTargetByCall.set(call, [...targets][0]);
+        });
+    });
+    const callGraph = (0, callGraph_1.combineCallGraphs)(modules.map((module) => module.analysis.callGraph), resolvedTargetByCall, generation);
+    const summaryOfTarget = (target) => {
+        const module = callableModule.get(target);
+        return module?.analysis.interprocedural.summaryOf(target);
+    };
+    return {
+        generation,
+        modules,
+        objects: publicObjects,
+        callGraph,
+        resolvedMethods: resolvedPublic,
+        resolvedConstructors,
+        diagnostics,
+        objectsOf: (expression) => {
+            const module = moduleOfNode.get(expression);
+            const values = valuesOfExpression.get(expression) ??
+                (module ? directValues(expression, module) : undefined);
+            if (!values)
+                return [];
+            return [...values]
+                .map((value) => publicOfMutable.get(value))
+                .filter((value) => value !== undefined);
+        },
+        objectOf: (expression) => {
+            const module = moduleOfNode.get(expression);
+            const values = valuesOfExpression.get(expression) ??
+                (module ? directValues(expression, module) : undefined);
+            if (values?.size !== 1)
+                return undefined;
+            return publicOfMutable.get([...values][0]);
+        },
+        methodCallOf: (call) => methodByCall.get(call) ?? methodByExpression.get(call.call),
+        summaryOfMethodCall: (call) => {
+            const method = methodByCall.get(call) ?? methodByExpression.get(call.call);
+            return method ? summaryOfTarget(method.target) : undefined;
+        },
+        effectsOfMethodCall: (call) => {
+            const method = methodByCall.get(call) ?? methodByExpression.get(call.call);
+            if (!method)
+                return [];
+            return summaryOfTarget(method.target)?.effects ?? [];
+        },
+    };
+}
+function stableSymbol(symbol, analysis) {
+    return (analysis.facts
+        .operationsOfSymbol(symbol)
+        .filter((operation) => operation.kind === "write").length === 0);
+}
+function unionInto(target, symbol, incoming) {
+    const values = target.get(symbol) ?? new Set();
+    const before = values.size;
+    incoming.forEach((value) => values.add(value));
+    target.set(symbol, values);
+    return values.size !== before;
+}
+function unionCallableInto(target, symbol, incoming) {
+    const values = target.get(symbol) ?? new Set();
+    const before = values.size;
+    incoming.forEach((value) => values.add(value));
+    target.set(symbol, values);
+    return values.size !== before;
+}
+function staticRequiredModule(call) {
+    return call.base.type === "Identifier" && call.base.name === "require"
+        ? (0, linker_1.staticStringArgument)(call.arguments[0])
+        : undefined;
+}
+function topLevelReturn(chunk) {
+    const statement = chunk.body.at(-1);
+    return statement?.type === "ReturnStatement" &&
+        statement.arguments.length === 1
+        ? statement.arguments[0]
+        : undefined;
+}
+function recognizeMixinFactory(callable, resolved) {
+    if (callable.parameters.length < 2)
+        return undefined;
+    const targetParameter = callable.parameters[0];
+    const prototypeParameter = callable.parameters[1];
+    const returned = callable.declaration.body.at(-1);
+    if (returned?.type !== "ReturnStatement" ||
+        returned.arguments.length !== 1 ||
+        returned.arguments[0].type !== "Identifier" ||
+        resolved.symbolOf(returned.arguments[0]) !== targetParameter)
+        return undefined;
+    const copyAssignments = [];
+    callable.declaration.body.forEach((statement) => {
+        if (statement.type !== "ForGenericStatement")
+            return;
+        const iterator = statement.iterators[0];
+        if (iterator.type !== "CallExpression" ||
+            iterator.base.type !== "Identifier" ||
+            iterator.base.name !== "pairs" ||
+            iterator.arguments.length === 0 ||
+            iterator.arguments[0].type !== "Identifier" ||
+            resolved.symbolOf(iterator.arguments[0]) !== prototypeParameter)
+            return;
+        const keyVariable = statement.variables.at(0);
+        const valueVariable = statement.variables.at(1);
+        if (!keyVariable || !valueVariable)
+            return;
+        const keySymbol = resolved.symbolOf(keyVariable);
+        const valueSymbol = resolved.symbolOf(valueVariable);
+        if (!keySymbol || !valueSymbol)
+            return;
+        walkStatements(statement.body, (node) => {
+            if (node.type !== "AssignmentStatement")
+                return;
+            const assignment = node;
+            assignment.variables.forEach((target, index) => {
+                const value = assignment.init.at(index);
+                if (!value)
+                    return;
+                if (target.type === "IndexExpression" &&
+                    target.base.type === "Identifier" &&
+                    resolved.symbolOf(target.base) === targetParameter &&
+                    target.index.type === "Identifier" &&
+                    resolved.symbolOf(target.index) === keySymbol &&
+                    value.type === "Identifier" &&
+                    resolved.symbolOf(value) === valueSymbol)
+                    copyAssignments.push(assignment);
+            });
+        });
+    });
+    return copyAssignments.length > 0
+        ? { targetParameter, prototypeParameter, copyAssignments }
+        : undefined;
+}
+function recognizeKeyPreservingTransfers(statement, resolved) {
+    const keyVariable = statement.variables.at(0);
+    const valueVariable = statement.variables.at(1);
+    if (!keyVariable)
+        return [];
+    const keySymbol = resolved.symbolOf(keyVariable);
+    const valueSymbol = valueVariable
+        ? resolved.symbolOf(valueVariable)
+        : undefined;
+    if (!keySymbol)
+        return [];
+    const first = statement.iterators.at(0);
+    let source;
+    if (first?.type === "CallExpression" &&
+        first.base.type === "Identifier" &&
+        first.base.name === "pairs")
+        source = first.arguments.at(0);
+    else if (first?.type === "Identifier" &&
+        first.name === "next" &&
+        statement.iterators.length >= 2)
+        source = statement.iterators[1];
+    if (!source)
+        return [];
+    const result = [];
+    walkStatements(statement.body, (node) => {
+        if (node.type !== "AssignmentStatement")
+            return;
+        node.variables.forEach((target, index) => {
+            const value = node.init.at(index);
+            if (target.type !== "IndexExpression" ||
+                target.index.type !== "Identifier" ||
+                resolved.symbolOf(target.index) !== keySymbol ||
+                !value)
+                return;
+            const copiesIteratorValue = value.type === "Identifier" &&
+                valueSymbol !== undefined &&
+                resolved.symbolOf(value) === valueSymbol;
+            const copiesSourceIndex = value.type === "IndexExpression" &&
+                value.index.type === "Identifier" &&
+                resolved.symbolOf(value.index) === keySymbol &&
+                sameExpressionIdentity(value.base, source, resolved);
+            if (copiesIteratorValue || copiesSourceIndex)
+                result.push({ assignment: node, source, target: target.base });
+        });
+    });
+    return result;
+}
+function sameExpressionIdentity(left, right, resolved) {
+    if (left === right)
+        return true;
+    return (left.type === "Identifier" &&
+        right.type === "Identifier" &&
+        resolved.symbolOf(left) !== undefined &&
+        resolved.symbolOf(left) === resolved.symbolOf(right));
+}
+function recognizeConstructor(callable, module, factories, targetsOf) {
+    const returned = callable.declaration.body.at(-1);
+    if (returned?.type !== "ReturnStatement" ||
+        returned.arguments.length !== 1 ||
+        returned.arguments[0].type !== "Identifier")
+        return undefined;
+    const returnedSymbol = module.resolved.symbolOf(returned.arguments[0]);
+    if (!returnedSymbol)
+        return undefined;
+    let template;
+    callable.declaration.body.forEach((statement) => {
+        if (statement.type !== "LocalStatement")
+            return;
+        statement.variables.forEach((variable, index) => {
+            if (module.resolved.symbolOf(variable) !== returnedSymbol)
+                return;
+            const value = statement.init.at(index);
+            if (!value)
+                return;
+            if (value.type !== "CallExpression")
+                return;
+            if (![...targetsOf(value)].some((target) => factories.has(target)))
+                return;
+            if (value.arguments.length < 2)
+                return;
+            template = {
+                callable,
+                returnedSymbol,
+                base: value.arguments[0],
+                prototype: value.arguments[1],
+                module,
+            };
+        });
+    });
+    return template;
+}
+function sourceRangeOf(node) {
+    const range = node.range;
+    return range ? { sourceRange: range } : {};
+}
+function valuesOfExpressionCleanup(cache, modules, retainCalls = false) {
+    modules.forEach((module) => {
+        visitExpressions(module.chunk.body, (expression) => {
+            if (retainCalls && expression.type === "CallExpression")
+                return;
+            if (expression.type !== "TableConstructorExpression")
+                cache.delete(expression);
+        });
+    });
+}
+function visitBindings(body, visit) {
+    walkStatements(body, (node) => {
+        if (node.type === "LocalStatement") {
+            const statement = node;
+            statement.variables.forEach((target, index) => {
+                const value = statement.init.at(index);
+                if (!value)
+                    return;
+                visit(target, value);
+            });
+        }
+        else if (node.type === "AssignmentStatement") {
+            const statement = node;
+            statement.variables.forEach((target, index) => {
+                const value = statement.init.at(index);
+                if (!value)
+                    return;
+                if (target.type === "Identifier")
+                    visit(target, value);
+            });
+        }
+    });
+}
+function walkStatements(body, visit) {
+    (0, astWalk_1.walkBlockDeep)(body, { onStatement: visit, onExpression: visit });
+}
+function visitExpressions(body, visit) {
+    (0, astWalk_1.walkBlockDeep)(body, { onExpression: visit });
+}