storm-lua-minify 0.2.0 → 0.9.0

package/dist/interproceduralAnalysis.js

@@ -0,0 +1,842 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeInterprocedural = analyzeInterprocedural;
+const optimizerValueDomain_1 = require("./optimizerValueDomain");
+const luaString_1 = require("./luaString");
+const luaString_2 = require("./luaString");
+/**
+ * Function summaries are symbolic transfers over parameter atoms. Recursive SCCs start at
+ * lattice bottom and grow monotonically, so a recursive edge cannot erase a provable base case.
+ */
+function analyzeInterprocedural(chunk, resolved, callGraph, options = {}) {
+    const mutable = new Map(callGraph.functions.map((callable) => [
+        callable,
+        {
+            returns: undefined,
+            effects: [],
+            escapes: [],
+            externalEffects: [],
+            allocationShapes: [],
+            escapedAllocations: [],
+            mayError: false,
+            mayInvokeMetamethod: false,
+        },
+    ]));
+    const callByExpression = new WeakMap();
+    callGraph.calls.forEach((call) => callByExpression.set(call.call, call));
+    const allocationTemplate = new WeakMap();
+    let nextAllocation = 0;
+    const contractOf = (call) => call.externalTargetName
+        ? options.externalContracts?.get(call.externalTargetName)
+        : undefined;
+    visitExpressions(chunk.body, (expression) => {
+        if (expression.type === "TableConstructorExpression")
+            allocationTemplate.set(expression, `table:${String(nextAllocation++)}`);
+    });
+    let changed = true;
+    let iterations = 0;
+    const iterationLimit = Math.max(1, callGraph.functions.length * 64);
+    while (changed) {
+        if (iterations++ > iterationLimit)
+            throw new Error("Interprocedural finite lattice failed to converge");
+        changed = false;
+        callGraph.functions.forEach((callable) => {
+            const evaluated = evaluateFunction(callable);
+            const previous = mutable.get(callable);
+            if (!previous)
+                throw new Error("Function summary is missing");
+            const next = {
+                returns: (0, optimizerValueDomain_1.joinOptimizerTuples)([
+                    ...(previous.returns ? [previous.returns] : []),
+                    ...evaluated.returns,
+                ]),
+                effects: uniqueEffects([...previous.effects, ...evaluated.effects]),
+                escapes: uniqueEscapes([...previous.escapes, ...evaluated.escapes]),
+                externalEffects: uniqueExternalEffects([
+                    ...previous.externalEffects,
+                    ...evaluated.externalEffects,
+                ]),
+                allocationShapes: joinAllocationShapes([
+                    ...previous.allocationShapes,
+                    ...evaluated.allocationShapes,
+                ]),
+                escapedAllocations: uniqueStrings([
+                    ...previous.escapedAllocations,
+                    ...evaluated.escapedAllocations,
+                ]),
+                mayError: previous.mayError || evaluated.mayError,
+                mayInvokeMetamethod: previous.mayInvokeMetamethod || evaluated.mayInvokeMetamethod,
+            };
+            if (summaryKey(previous) !== summaryKey(next)) {
+                mutable.set(callable, next);
+                changed = true;
+            }
+        });
+    }
+    const summaries = callGraph.functions.map((callable) => {
+        const summary = mutable.get(callable);
+        if (!summary)
+            throw new Error("Function summary is missing");
+        return {
+            callable,
+            ...summary,
+            returns: summary.returns ?? optimizerValueDomain_1.EMPTY_OPTIMIZER_TUPLE,
+            converged: true,
+        };
+    });
+    const summaryByCallable = new Map(summaries.map((summary) => [summary.callable, summary]));
+    const diagnostics = [
+        ...callGraph.calls.map((call) => ({
+            reason: contractOf(call)
+                ? "external-contract-used"
+                : call.hasUnknownTarget
+                    ? "unknown-call-target"
+                    : "resolved-call-target",
+            callId: call.id,
+            ...sourceRangeOf(call.call),
+        })),
+        ...callGraph.sccs
+            .filter((scc) => scc.recursive)
+            .map((scc) => ({
+            reason: "recursive-scc-converged",
+            functionId: scc.functions[0].id,
+            ...sourceRangeOf(scc.functions[0].declaration),
+        })),
+        ...summaries.flatMap((summary) => [
+            ...summary.effects.map(() => ({
+                reason: "parameter-field-effect",
+                functionId: summary.callable.id,
+                ...sourceRangeOf(summary.callable.declaration),
+            })),
+            ...summary.escapes.map(() => ({
+                reason: "parameter-escape",
+                functionId: summary.callable.id,
+                ...sourceRangeOf(summary.callable.declaration),
+            })),
+        ]),
+    ];
+    const returnsOf = (call) => {
+        const actuals = actualValues(call.call, new Map());
+        const instantiated = [...call.targets].map((target) => instantiateTuple(safeSummaryReturns(summaryByCallable.get(target)), actuals, call));
+        const contract = contractOf(call);
+        if (contract)
+            instantiated.push(instantiateTuple(contract.returns, actuals, call));
+        else if (call.hasUnknownTarget)
+            instantiated.push((0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                kind: "unknown",
+                reasons: ["unknown-call-target"],
+            }));
+        return instantiated.length > 0
+            ? (0, optimizerValueDomain_1.joinOptimizerTuples)(instantiated)
+            : (0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                kind: "unknown",
+                reasons: ["unresolved-call-target"],
+            });
+    };
+    const symbolicReturnsOf = (call) => {
+        const tuples = [...call.targets].map((target) => safeSummaryReturns(summaryByCallable.get(target)));
+        const contract = contractOf(call);
+        if (contract)
+            tuples.push(contract.returns);
+        else if (call.hasUnknownTarget)
+            tuples.push((0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                kind: "unknown",
+                reasons: ["unknown-call-target"],
+            }));
+        return tuples.length > 0
+            ? (0, optimizerValueDomain_1.joinOptimizerTuples)(tuples)
+            : optimizerValueDomain_1.EMPTY_OPTIMIZER_TUPLE;
+    };
+    return {
+        generation: callGraph.generation,
+        callGraph,
+        summaries,
+        diagnostics,
+        summaryOf: (callable) => {
+            const summary = summaryByCallable.get(callable);
+            if (!summary)
+                throw new Error("Function summary is missing");
+            return summary;
+        },
+        symbolicReturnsOf,
+        returnsOf,
+        effectsOf: (call) => {
+            const effects = [...call.targets].flatMap((target) => summaryByCallable.get(target)?.effects ?? []);
+            return uniqueInstantiatedEffects([
+                ...effects.map((effect) => ({
+                    argumentIndex: effect.parameterIndex,
+                    access: effect.access,
+                    ...(effect.staticKey === undefined
+                        ? {}
+                        : { staticKey: effect.staticKey }),
+                })),
+                ...(contractOf(call)?.effects ?? []),
+            ]);
+        },
+        escapesArgument: (call, argumentIndex) => (call.hasUnknownTarget &&
+            (contractOf(call)
+                ? (contractOf(call)?.escapingArguments?.has(argumentIndex) ?? false)
+                : true)) ||
+            [...call.targets].some((target) => (summaryByCallable.get(target)?.escapes ?? []).some((escape) => escape.parameterIndex === argumentIndex &&
+                escape.reason !== "return")),
+        shapeOfAllocation: (allocationId) => {
+            const templateId = allocationId.split("/").at(-1);
+            return summaries
+                .flatMap((summary) => summary.allocationShapes)
+                .find((shape) => shape.templateId === templateId);
+        },
+    };
+    function evaluateFunction(callable) {
+        const evaluation = {
+            returns: [],
+            effects: [],
+            escapes: [],
+            externalEffects: [],
+            allocationShapes: [],
+            escapedAllocations: [],
+            evaluatedCalls: new WeakMap(),
+            mayError: false,
+            mayInvokeMetamethod: false,
+        };
+        const environment = new Map();
+        callable.parameters.forEach((parameter, index) => environment.set(parameter, (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "parameter", index }])));
+        evaluateBlock(callable.declaration.body, environment, evaluation);
+        if (evaluation.returns.length === 0)
+            evaluation.returns.push(optimizerValueDomain_1.EMPTY_OPTIMIZER_TUPLE);
+        return evaluation;
+    }
+    function evaluateBlock(body, environment, evaluation) {
+        body.forEach((statement) => {
+            switch (statement.type) {
+                case "LocalStatement":
+                case "AssignmentStatement": {
+                    const values = valuesOfExpressionList(statement.init, environment, evaluation, statement.variables.length);
+                    statement.variables.forEach((target, index) => {
+                        if (target.type === "Identifier") {
+                            const symbol = resolved.symbolOf(target);
+                            if (symbol &&
+                                (statement.type === "LocalStatement" || environment.has(symbol)))
+                                environment.set(symbol, values[index] ?? (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "nil" }]));
+                            else {
+                                recordStoreEscapes(values[index] ?? (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "nil" }]), evaluation);
+                                evaluation.externalEffects.push({
+                                    access: "write",
+                                    id: symbol ? `upvalue:${String(symbol.id)}` : target.name,
+                                });
+                            }
+                        }
+                        else {
+                            recordStoreEscapes(values[index] ?? (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "nil" }]), evaluation);
+                            recordTableEffect(target, "write", environment, evaluation);
+                        }
+                    });
+                    return;
+                }
+                case "ReturnStatement": {
+                    const tuple = tupleOfExpressionList(statement.arguments, environment, evaluation);
+                    tuple.prefix.forEach((value) => {
+                        parameterIndexes(value).forEach((parameterIndex) => evaluation.escapes.push({
+                            parameterIndex,
+                            reason: "return",
+                        }));
+                    });
+                    evaluation.returns.push(tuple);
+                    return;
+                }
+                case "CallStatement":
+                    valueOf(statement.expression, environment, evaluation);
+                    return;
+                case "IfStatement": {
+                    const branches = statement.clauses.map((clause) => {
+                        if (clause.type !== "ElseClause")
+                            valueOf(clause.condition, environment, evaluation);
+                        const branch = new Map(environment);
+                        evaluateBlock(clause.body, branch, evaluation);
+                        return branch;
+                    });
+                    if (!statement.clauses.some((clause) => clause.type === "ElseClause"))
+                        branches.push(new Map(environment));
+                    joinEnvironments(environment, branches);
+                    return;
+                }
+                case "DoStatement": {
+                    const block = new Map(environment);
+                    evaluateBlock(statement.body, block, evaluation);
+                    projectOuterEnvironment(environment, block);
+                    return;
+                }
+                case "WhileStatement":
+                case "RepeatStatement": {
+                    valueOf(statement.condition, environment, evaluation);
+                    const loop = new Map(environment);
+                    evaluateBlock(statement.body, loop, evaluation);
+                    joinEnvironments(environment, [environment, loop]);
+                    return;
+                }
+                case "ForNumericStatement": {
+                    valueOf(statement.start, environment, evaluation);
+                    valueOf(statement.end, environment, evaluation);
+                    if (statement.step)
+                        valueOf(statement.step, environment, evaluation);
+                    const loop = new Map(environment);
+                    evaluateBlock(statement.body, loop, evaluation);
+                    joinEnvironments(environment, [new Map(environment), loop]);
+                    return;
+                }
+                case "ForGenericStatement": {
+                    valuesOfExpressionList(statement.iterators, environment, evaluation, statement.variables.length);
+                    const loop = new Map(environment);
+                    evaluateBlock(statement.body, loop, evaluation);
+                    joinEnvironments(environment, [new Map(environment), loop]);
+                    return;
+                }
+                case "FunctionDeclaration":
+                    recordCaptures(statement, environment, evaluation);
+                    return;
+                case "BreakStatement":
+                case "LabelStatement":
+                case "GotoStatement":
+                    return;
+            }
+        });
+    }
+    function valueOf(expression, environment, evaluation) {
+        if (!expression)
+            return (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "nil" }]);
+        switch (expression.type) {
+            case "NilLiteral":
+                return (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "nil" }]);
+            case "BooleanLiteral":
+                return (0, optimizerValueDomain_1.finiteOptimizerValue)([
+                    { kind: "boolean", value: expression.value },
+                ]);
+            case "NumericLiteral":
+                return (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "number", raw: expression.raw }]);
+            case "StringLiteral":
+                return (0, optimizerValueDomain_1.finiteOptimizerValue)([
+                    { kind: "string", value: expression.value },
+                ]);
+            case "Identifier": {
+                const symbol = resolved.symbolOf(expression);
+                const knownFunction = symbol
+                    ? callGraph.functionOfSymbol(symbol)
+                    : undefined;
+                if (knownFunction)
+                    return (0, optimizerValueDomain_1.finiteOptimizerValue)([
+                        { kind: "function", id: String(knownFunction.id) },
+                    ]);
+                return symbol
+                    ? (environment.get(symbol) ??
+                        (0, optimizerValueDomain_1.unknownOptimizerValue)("symbol-value-unavailable"))
+                    : (evaluation.externalEffects.push({
+                        access: "read",
+                        id: expression.name,
+                    }),
+                        (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "external", id: expression.name }], ["external-value"]));
+            }
+            case "FunctionDeclaration": {
+                const target = callGraph.functionOf(expression);
+                recordCaptures(expression, environment, evaluation);
+                return target
+                    ? (0, optimizerValueDomain_1.finiteOptimizerValue)([{ kind: "function", id: String(target.id) }])
+                    : (0, optimizerValueDomain_1.unknownOptimizerValue)("function-unindexed");
+            }
+            case "TableConstructorExpression": {
+                const fields = [];
+                let unknownKeyWrite = false;
+                let arrayIndex = 1;
+                expression.fields.forEach((field) => {
+                    let staticKey;
+                    if (field.type === "TableKeyString") {
+                        staticKey = (0, luaString_1.luaByteStringKey)((0, luaString_1.luaByteStringOfText)(field.key.name));
+                    }
+                    else if (field.type === "TableKey") {
+                        if (field.key.type === "StringLiteral") {
+                            const decoded = (0, luaString_2.decodeLuaStringLiteral)(field.key);
+                            if (decoded.ok)
+                                staticKey = (0, luaString_1.luaByteStringKey)(decoded.value);
+                        }
+                        valueOf(field.key, environment, evaluation);
+                    }
+                    else {
+                        staticKey = `number:${String(arrayIndex++)}`;
+                    }
+                    const fieldValue = valueOf(field.value, environment, evaluation);
+                    if (staticKey === undefined)
+                        unknownKeyWrite = true;
+                    else
+                        fields.push({ staticKey, value: fieldValue });
+                });
+                const templateId = allocationTemplate.get(expression) ?? "table:unindexed";
+                evaluation.allocationShapes.push({
+                    templateId,
+                    fields,
+                    unknownKeyWrite,
+                });
+                return (0, optimizerValueDomain_1.finiteOptimizerValue)([
+                    {
+                        kind: "allocation",
+                        allocationKind: "table",
+                        id: templateId,
+                    },
+                ]);
+            }
+            case "MemberExpression":
+            case "IndexExpression":
+                recordTableEffect(expression, "read", environment, evaluation);
+                evaluation.mayError = true;
+                evaluation.mayInvokeMetamethod = true;
+                return (0, optimizerValueDomain_1.unknownOptimizerValue)("table-read-value");
+            case "CallExpression":
+            case "TableCallExpression":
+            case "StringCallExpression": {
+                const cached = evaluation.evaluatedCalls.get(expression);
+                if (cached)
+                    return (0, optimizerValueDomain_1.valueAtOptimizerTupleSlot)(cached.returns, 0);
+                const call = callByExpression.get(expression);
+                const actuals = actualValues(expression, environment, evaluation);
+                const contract = call ? contractOf(call) : undefined;
+                if (!call || (call.hasUnknownTarget && !contract)) {
+                    evaluation.externalEffects.push({
+                        access: "call",
+                        id: expression.base.type === "Identifier"
+                            ? expression.base.name
+                            : "unknown-call",
+                    });
+                    actuals.forEach((actual) => {
+                        recordStoreEscapes(actual, evaluation, "unknown-call");
+                        parameterIndexes(actual).forEach((parameterIndex) => evaluation.escapes.push({
+                            parameterIndex,
+                            reason: "unknown-call",
+                        }));
+                    });
+                    evaluation.mayError = true;
+                    evaluation.mayInvokeMetamethod = true;
+                }
+                if (!call)
+                    return (0, optimizerValueDomain_1.unknownOptimizerValue)("call-unindexed");
+                const tuples = [...call.targets].flatMap((target) => {
+                    const targetSummary = mutable.get(target);
+                    if (!targetSummary)
+                        throw new Error("Function summary is missing");
+                    targetSummary.effects.forEach((effect) => {
+                        parameterIndexes(actuals[effect.parameterIndex]).forEach((parameterIndex) => evaluation.effects.push({
+                            parameterIndex,
+                            access: effect.access,
+                            ...(effect.staticKey === undefined
+                                ? {}
+                                : { staticKey: effect.staticKey }),
+                        }));
+                    });
+                    targetSummary.escapes.forEach((escape) => {
+                        if (escape.reason !== "return")
+                            allocationIds(actuals[escape.parameterIndex]).forEach((id) => evaluation.escapedAllocations.push(id));
+                        parameterIndexes(actuals[escape.parameterIndex]).forEach((parameterIndex) => evaluation.escapes.push({
+                            parameterIndex,
+                            reason: escape.reason,
+                        }));
+                    });
+                    evaluation.externalEffects.push(...targetSummary.externalEffects);
+                    evaluation.mayError ||= targetSummary.mayError;
+                    evaluation.mayInvokeMetamethod ||= targetSummary.mayInvokeMetamethod;
+                    return targetSummary.returns
+                        ? [
+                            instantiateTuple(rejectEscapedAllocations(targetSummary.returns, targetSummary.escapedAllocations), actuals, call),
+                        ]
+                        : [];
+                });
+                if (contract) {
+                    evaluation.mayError ||= contract.mayError ?? false;
+                    evaluation.mayInvokeMetamethod ||=
+                        contract.mayInvokeMetamethod ?? false;
+                    (contract.effects ?? []).forEach((effect) => {
+                        parameterIndexes(actuals[effect.argumentIndex]).forEach((parameterIndex) => evaluation.effects.push({
+                            parameterIndex,
+                            access: effect.access,
+                            ...(effect.staticKey === undefined
+                                ? {}
+                                : { staticKey: effect.staticKey }),
+                        }));
+                    });
+                    contract.escapingArguments?.forEach((argumentIndex) => {
+                        const actual = actuals.at(argumentIndex);
+                        if (actual)
+                            recordStoreEscapes(actual, evaluation, "unknown-call");
+                        parameterIndexes(actual).forEach((parameterIndex) => evaluation.escapes.push({
+                            parameterIndex,
+                            reason: "unknown-call",
+                        }));
+                    });
+                    tuples.push(instantiateTuple(contract.returns, actuals, call));
+                }
+                else if (call.hasUnknownTarget)
+                    tuples.push((0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                        kind: "unknown",
+                        reasons: ["unknown-call-target"],
+                    }));
+                const returns = tuples.length > 0
+                    ? (0, optimizerValueDomain_1.joinOptimizerTuples)(tuples)
+                    : call.targets.size > 0
+                        ? (0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                            kind: "unknown",
+                            reasons: ["recursive-summary-bottom"],
+                        })
+                        : optimizerValueDomain_1.EMPTY_OPTIMIZER_TUPLE;
+                evaluation.evaluatedCalls.set(expression, { actuals, returns });
+                return (0, optimizerValueDomain_1.valueAtOptimizerTupleSlot)(returns, 0);
+            }
+            case "BinaryExpression":
+            case "LogicalExpression":
+                valueOf(expression.left, environment, evaluation);
+                valueOf(expression.right, environment, evaluation);
+                evaluation.mayError = true;
+                evaluation.mayInvokeMetamethod = true;
+                return (0, optimizerValueDomain_1.unknownOptimizerValue)("computed-expression");
+            case "UnaryExpression":
+                valueOf(expression.argument, environment, evaluation);
+                evaluation.mayError = true;
+                evaluation.mayInvokeMetamethod = true;
+                return (0, optimizerValueDomain_1.unknownOptimizerValue)("computed-expression");
+            case "VarargLiteral":
+                return (0, optimizerValueDomain_1.unknownOptimizerValue)("vararg-value");
+        }
+    }
+    function actualValues(call, environment, evaluation) {
+        const sink = evaluation ??
+            {
+                returns: [],
+                effects: [],
+                escapes: [],
+                externalEffects: [],
+                allocationShapes: [],
+                escapedAllocations: [],
+                evaluatedCalls: new WeakMap(),
+                mayError: false,
+                mayInvokeMetamethod: false,
+            };
+        const explicit = call.type === "CallExpression"
+            ? call.arguments
+            : [
+                call.type === "TableCallExpression"
+                    ? call.arguments
+                    : call.argument,
+            ];
+        const receiver = call.base.type === "MemberExpression" && call.base.indexer === ":"
+            ? [call.base.base]
+            : [];
+        return valuesOfExpressionList([...receiver, ...explicit], environment, sink, Number.POSITIVE_INFINITY);
+    }
+    function valuesOfExpressionList(expressions, environment, evaluation, count) {
+        const tuple = tupleOfExpressionList(expressions, environment, evaluation);
+        const available = Number.isFinite(count)
+            ? count
+            : Math.max(expressions.length, tuple.prefix.length);
+        return Array.from({ length: available }, (_, index) => (0, optimizerValueDomain_1.valueAtOptimizerTupleSlot)(tuple, index));
+    }
+    function tupleOfExpressionList(expressions, environment, evaluation) {
+        if (expressions.length === 0)
+            return optimizerValueDomain_1.EMPTY_OPTIMIZER_TUPLE;
+        const leading = expressions
+            .slice(0, -1)
+            .map((expression) => valueOf(expression, environment, evaluation));
+        const last = expressions.at(-1);
+        if (!last)
+            return (0, optimizerValueDomain_1.finiteOptimizerTuple)(leading);
+        const single = valueOf(last, environment, evaluation);
+        const tail = tupleOfLastExpression(last, environment, evaluation, single);
+        return (0, optimizerValueDomain_1.finiteOptimizerTuple)([...leading, ...tail.prefix], tail.tail);
+    }
+    function tupleOfLastExpression(expression, environment, evaluation, singleValue) {
+        if (expression.type === "VarargLiteral") {
+            return (0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                kind: "unknown",
+                reasons: ["vararg-tail"],
+            });
+        }
+        if (expression.type !== "CallExpression" &&
+            expression.type !== "TableCallExpression" &&
+            expression.type !== "StringCallExpression")
+            return (0, optimizerValueDomain_1.finiteOptimizerTuple)([singleValue]);
+        const call = callByExpression.get(expression);
+        if (!call)
+            return (0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                kind: "unknown",
+                reasons: ["call-unindexed"],
+            });
+        valueOf(expression, environment, evaluation);
+        const actuals = evaluation.evaluatedCalls.get(expression)?.actuals;
+        if (!actuals)
+            return (0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                kind: "unknown",
+                reasons: ["call-evaluation-missing"],
+            });
+        const tuples = [...call.targets].flatMap((target) => {
+            const returns = mutable.get(target)?.returns;
+            return returns
+                ? [
+                    instantiateTuple(rejectEscapedAllocations(returns, mutable.get(target)?.escapedAllocations ?? []), actuals, call),
+                ]
+                : [];
+        });
+        const contract = contractOf(call);
+        if (contract)
+            tuples.push(instantiateTuple(contract.returns, actuals, call));
+        else if (call.hasUnknownTarget)
+            tuples.push((0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                kind: "unknown",
+                reasons: ["unknown-call-target"],
+            }));
+        return tuples.length > 0
+            ? (0, optimizerValueDomain_1.joinOptimizerTuples)(tuples)
+            : call.targets.size > 0
+                ? (0, optimizerValueDomain_1.finiteOptimizerTuple)([], {
+                    kind: "unknown",
+                    reasons: ["recursive-summary-bottom"],
+                })
+                : optimizerValueDomain_1.EMPTY_OPTIMIZER_TUPLE;
+    }
+    function recordTableEffect(expression, access, environment, evaluation) {
+        const base = valueOf(expression.base, environment, evaluation);
+        const staticKey = expression.type === "MemberExpression"
+            ? (0, luaString_1.luaByteStringKey)((0, luaString_1.luaByteStringOfText)(expression.identifier.name))
+            : expression.index.type === "StringLiteral"
+                ? (() => {
+                    const decoded = (0, luaString_2.decodeLuaStringLiteral)(expression.index);
+                    return decoded.ok ? (0, luaString_1.luaByteStringKey)(decoded.value) : undefined;
+                })()
+                : undefined;
+        parameterIndexes(base).forEach((parameterIndex) => evaluation.effects.push({
+            parameterIndex,
+            access,
+            ...(staticKey === undefined ? {} : { staticKey }),
+        }));
+        if (expression.type === "IndexExpression")
+            valueOf(expression.index, environment, evaluation);
+    }
+    function recordCaptures(declaration, environment, evaluation) {
+        visitExpressions(declaration.body, (expression) => {
+            if (expression.type !== "Identifier")
+                return;
+            const symbol = resolved.symbolOf(expression);
+            const value = symbol ? environment.get(symbol) : undefined;
+            parameterIndexes(value).forEach((parameterIndex) => evaluation.escapes.push({ parameterIndex, reason: "capture" }));
+        });
+    }
+}
+function instantiateTuple(tuple, actuals, call) {
+    const instantiate = (value) => (0, optimizerValueDomain_1.joinOptimizerValues)([
+        (0, optimizerValueDomain_1.finiteOptimizerValue)(value.atoms.flatMap((atom) => {
+            if (atom.kind === "parameter")
+                return [...(actuals[atom.index]?.atoms ?? [])];
+            if (atom.kind === "allocation")
+                return [{ ...atom, id: `call:${String(call.id)}/${atom.id}` }];
+            return [atom];
+        }), value.unknownReasons),
+        ...value.atoms
+            .filter((atom) => atom.kind === "parameter")
+            .map((atom) => actuals[atom.index] ?? (0, optimizerValueDomain_1.unknownOptimizerValue)("missing-argument")),
+    ]);
+    return (0, optimizerValueDomain_1.finiteOptimizerTuple)(tuple.prefix.map(instantiate), tuple.tail.kind === "vararg"
+        ? { kind: "vararg", value: instantiate(tuple.tail.value) }
+        : tuple.tail);
+}
+function safeSummaryReturns(summary) {
+    return summary
+        ? rejectEscapedAllocations(summary.returns, summary.escapedAllocations)
+        : optimizerValueDomain_1.EMPTY_OPTIMIZER_TUPLE;
+}
+function rejectEscapedAllocations(tuple, escapedAllocations) {
+    if (escapedAllocations.length === 0)
+        return tuple;
+    const escaped = new Set(escapedAllocations);
+    const reject = (value) => {
+        const retained = value.atoms.filter((atom) => atom.kind !== "allocation" || !escaped.has(atom.id));
+        return (0, optimizerValueDomain_1.finiteOptimizerValue)(retained, retained.length === value.atoms.length
+            ? value.unknownReasons
+            : [...value.unknownReasons, "escaped-allocation"]);
+    };
+    return (0, optimizerValueDomain_1.finiteOptimizerTuple)(tuple.prefix.map(reject), tuple.tail.kind === "vararg"
+        ? { kind: "vararg", value: reject(tuple.tail.value) }
+        : tuple.tail);
+}
+function parameterIndexes(value) {
+    return value
+        ? value.atoms.flatMap((atom) => atom.kind === "parameter" ? [atom.index] : [])
+        : [];
+}
+function recordStoreEscapes(value, evaluation, parameterReason = "store") {
+    parameterIndexes(value).forEach((parameterIndex) => evaluation.escapes.push({ parameterIndex, reason: parameterReason }));
+    allocationIds(value).forEach((id) => evaluation.escapedAllocations.push(id));
+}
+function allocationIds(value) {
+    return value
+        ? value.atoms.flatMap((atom) => atom.kind === "allocation" ? [atom.id] : [])
+        : [];
+}
+function projectOuterEnvironment(target, source) {
+    [...target.keys()].forEach((symbol) => {
+        const value = source.get(symbol);
+        if (value)
+            target.set(symbol, value);
+    });
+}
+function uniqueStrings(values) {
+    return [...new Set(values)].sort();
+}
+function joinEnvironments(target, branches) {
+    const symbols = new Set(branches.flatMap((branch) => [...branch.keys()]));
+    symbols.forEach((symbol) => target.set(symbol, (0, optimizerValueDomain_1.joinOptimizerValues)(branches.map((branch) => branch.get(symbol) ?? (0, optimizerValueDomain_1.unknownOptimizerValue)("branch-local")))));
+}
+function uniqueEffects(effects) {
+    const byKey = new Map();
+    effects.forEach((effect) => byKey.set(`${String(effect.parameterIndex)}:${effect.access}:${effect.staticKey ?? "*"}`, effect));
+    return [...byKey.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, effect]) => effect);
+}
+function uniqueInstantiatedEffects(effects) {
+    const byKey = new Map();
+    effects.forEach((effect) => byKey.set(`${String(effect.argumentIndex)}:${effect.access}:${effect.staticKey ?? "*"}`, effect));
+    return [...byKey.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, effect]) => effect);
+}
+function uniqueEscapes(escapes) {
+    const byKey = new Map();
+    escapes.forEach((escape) => byKey.set(`${String(escape.parameterIndex)}:${escape.reason}`, escape));
+    return [...byKey.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, escape]) => escape);
+}
+function uniqueExternalEffects(effects) {
+    const byKey = new Map();
+    effects.forEach((effect) => byKey.set(`${effect.access}:${effect.id}`, effect));
+    return [...byKey.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, effect]) => effect);
+}
+function joinAllocationShapes(shapes) {
+    const byTemplate = new Map();
+    shapes.forEach((shape) => {
+        const entries = byTemplate.get(shape.templateId) ?? [];
+        entries.push(shape);
+        byTemplate.set(shape.templateId, entries);
+    });
+    return [...byTemplate.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([templateId, alternatives]) => {
+        const keys = new Set(alternatives.flatMap((shape) => shape.fields.map((field) => field.staticKey)));
+        const fields = [...keys].sort().flatMap((staticKey) => {
+            const values = alternatives.flatMap((shape) => {
+                const field = shape.fields.find((candidate) => candidate.staticKey === staticKey);
+                return field ? [field.value] : [];
+            });
+            return values.length === alternatives.length
+                ? [{ staticKey, value: (0, optimizerValueDomain_1.joinOptimizerValues)(values) }]
+                : [];
+        });
+        return {
+            templateId,
+            fields,
+            unknownKeyWrite: alternatives.some((shape) => shape.unknownKeyWrite),
+        };
+    });
+}
+function summaryKey(summary) {
+    return JSON.stringify(summary);
+}
+function sourceRangeOf(node) {
+    const range = node.range;
+    return range ? { sourceRange: range } : {};
+}
+function visitExpressions(body, visit) {
+    const expression = (value) => {
+        visit(value);
+        switch (value.type) {
+            case "FunctionDeclaration":
+                visitExpressions(value.body, visit);
+                return;
+            case "CallExpression":
+                expression(value.base);
+                value.arguments.forEach(expression);
+                return;
+            case "TableCallExpression":
+                expression(value.base);
+                expression(value.arguments);
+                return;
+            case "StringCallExpression":
+                expression(value.base);
+                expression(value.argument);
+                return;
+            case "BinaryExpression":
+            case "LogicalExpression":
+                expression(value.left);
+                expression(value.right);
+                return;
+            case "UnaryExpression":
+                expression(value.argument);
+                return;
+            case "MemberExpression":
+                expression(value.base);
+                return;
+            case "IndexExpression":
+                expression(value.base);
+                expression(value.index);
+                return;
+            case "TableConstructorExpression":
+                value.fields.forEach((field) => {
+                    if (field.type === "TableKey")
+                        expression(field.key);
+                    expression(field.value);
+                });
+                return;
+            default:
+                return;
+        }
+    };
+    body.forEach((statement) => {
+        switch (statement.type) {
+            case "LocalStatement":
+            case "AssignmentStatement":
+                statement.init.forEach(expression);
+                return;
+            case "CallStatement":
+                expression(statement.expression);
+                return;
+            case "ReturnStatement":
+                statement.arguments.forEach(expression);
+                return;
+            case "FunctionDeclaration":
+                visit(statement);
+                visitExpressions(statement.body, visit);
+                return;
+            case "DoStatement":
+            case "WhileStatement":
+            case "RepeatStatement":
+                if ("condition" in statement)
+                    expression(statement.condition);
+                visitExpressions(statement.body, visit);
+                return;
+            case "IfStatement":
+                statement.clauses.forEach((clause) => {
+                    if (clause.type !== "ElseClause")
+                        expression(clause.condition);
+                    visitExpressions(clause.body, visit);
+                });
+                return;
+            case "ForNumericStatement":
+                expression(statement.start);
+                expression(statement.end);
+                if (statement.step)
+                    expression(statement.step);
+                visitExpressions(statement.body, visit);
+                return;
+            case "ForGenericStatement":
+                statement.iterators.forEach(expression);
+                visitExpressions(statement.body, visit);
+                return;
+            default:
+                return;
+        }
+    });
+}