storm-lua-minify 0.2.0 → 0.9.0

package/dist/optimizerAnalysis.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPTIMIZER_ANALYSIS_CACHE_KEY = void 0;
+exports.analyzeOptimizer = analyzeOptimizer;
+exports.analyzeOptimizerAtGeneration = analyzeOptimizerAtGeneration;
+const optimizerFacts_1 = require("./optimizerFacts");
+const valueFlow_1 = require("./valueFlow");
+const tableEffects_1 = require("./tableEffects");
+const statementDataflow_1 = require("./statementDataflow");
+const callGraph_1 = require("./callGraph");
+const interproceduralAnalysis_1 = require("./interproceduralAnalysis");
+exports.OPTIMIZER_ANALYSIS_CACHE_KEY = {};
+/**
+ * 一つのAST世代に属するoptimizer解析をまとめて構築する。
+ *
+ * sub-analysisをpass側で個別に生成させないことが重要である。これによりtable解析と
+ * value flowが同じallocation identity・CFG世代を共有し、AST変更時には
+ * PassOrchestratorがsnapshot全体を一度に破棄できる。
+ */
+function analyzeOptimizer(chunk, resolved, options = {}) {
+    const generation = options.generation ?? 0;
+    const facts = (0, optimizerFacts_1.analyzeOptimizerFacts)(chunk, resolved, {
+        ...options,
+        generation,
+    });
+    const callGraph = (0, callGraph_1.analyzeCallGraph)(chunk, resolved, facts);
+    const interprocedural = (0, interproceduralAnalysis_1.analyzeInterprocedural)(chunk, resolved, callGraph, options.interprocedural);
+    const valueFlow = (0, valueFlow_1.analyzeValueFlow)(chunk, resolved, facts, generation, interprocedural);
+    const tableEffects = (0, tableEffects_1.analyzeTableEffects)(chunk, resolved, valueFlow, facts, interprocedural);
+    const statementDataflow = (0, statementDataflow_1.analyzeStatementDataflow)(chunk, facts, valueFlow);
+    return {
+        generation,
+        facts,
+        callGraph,
+        interprocedural,
+        valueFlow,
+        tableEffects,
+        statementDataflow,
+    };
+}
+function analyzeOptimizerAtGeneration(chunk, resolved, generation) {
+    return analyzeOptimizer(chunk, resolved, { generation });
+}

package/dist/optimizerDiagnostics.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizationDiagnosticCollector = void 0;
+exports.summarizeOptimizationDiagnostics = summarizeOptimizationDiagnostics;
+class OptimizationDiagnosticCollector {
+    diagnosticsValue = [];
+    get diagnostics() {
+        return this.diagnosticsValue;
+    }
+    record(diagnostic) {
+        this.diagnosticsValue.push({ ...diagnostic });
+    }
+}
+exports.OptimizationDiagnosticCollector = OptimizationDiagnosticCollector;
+function summarizeOptimizationDiagnostics(diagnostics) {
+    const buckets = new Map();
+    let acceptedCandidates = 0;
+    let rejectedCandidates = 0;
+    let estimatedByteSavings = 0;
+    let estimatedOpportunityBytes = 0;
+    diagnostics.forEach((diagnostic) => {
+        const count = diagnostic.candidateSize ?? 1;
+        if (diagnostic.decision === "accepted") {
+            acceptedCandidates += count;
+            estimatedByteSavings += diagnostic.estimatedByteSavings ?? 0;
+        }
+        else {
+            rejectedCandidates += count;
+            estimatedOpportunityBytes += diagnostic.estimatedOpportunityBytes ?? 0;
+        }
+        const runtimeProfile = diagnostic.runtimeProfile ?? "unknown";
+        const moduleName = diagnostic.moduleName ?? "unknown";
+        const key = [
+            runtimeProfile,
+            moduleName,
+            diagnostic.pass,
+            diagnostic.decision,
+            diagnostic.reason,
+        ].join("\u0000");
+        const current = buckets.get(key) ?? {
+            runtimeProfile,
+            moduleName,
+            pass: diagnostic.pass,
+            decision: diagnostic.decision,
+            reason: diagnostic.reason,
+            candidateCount: 0,
+            estimatedByteSavings: 0,
+            estimatedOpportunityBytes: 0,
+        };
+        current.candidateCount += count;
+        current.estimatedByteSavings += diagnostic.estimatedByteSavings ?? 0;
+        current.estimatedOpportunityBytes +=
+            diagnostic.estimatedOpportunityBytes ?? 0;
+        buckets.set(key, current);
+    });
+    return {
+        acceptedCandidates,
+        rejectedCandidates,
+        estimatedByteSavings,
+        estimatedOpportunityBytes,
+        buckets: [...buckets]
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([, bucket]) => ({ ...bucket })),
+    };
+}

package/dist/optimizerFacts.js

@@ -0,0 +1,529 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPTIMIZER_FACTS_CACHE_KEY = void 0;
+exports.analyzeOptimizerFactsAtGeneration = analyzeOptimizerFactsAtGeneration;
+exports.analyzeOptimizerFacts = analyzeOptimizerFacts;
+const luaString_1 = require("./luaString");
+/** Stable cache identity used by PassOrchestrator for language-level facts. */
+exports.OPTIMIZER_FACTS_CACHE_KEY = {};
+function analyzeOptimizerFactsAtGeneration(chunk, resolved, generation) {
+    return analyzeOptimizerFacts(chunk, resolved, { generation });
+}
+const LANGUAGE_NO_EFFECT = {
+    mayError: {
+        value: "no",
+        evidence: { kind: "language", reason: "literal-or-function-construction" },
+    },
+    mayInvokeMetamethod: {
+        value: "no",
+        evidence: { kind: "language", reason: "literal-or-function-construction" },
+    },
+};
+const LANGUAGE_MAY_EFFECT = {
+    mayError: {
+        value: "may",
+        evidence: { kind: "language", reason: "operation-may-raise" },
+    },
+    mayInvokeMetamethod: {
+        value: "may",
+        evidence: { kind: "language", reason: "operation-may-dispatch-metamethod" },
+    },
+};
+/** Collects syntax-level optimizer facts. It deliberately performs no CFG or interprocedural inference. */
+function analyzeOptimizerFacts(chunk, resolved, options = {}) {
+    const operations = [];
+    const unknowns = [];
+    const byOwner = new WeakMap();
+    const withinOwner = new WeakMap();
+    const byOrigin = new WeakMap();
+    const bySymbol = new Map();
+    const expressionFacts = new WeakMap();
+    const valueSlots = new WeakMap();
+    let nextOperationId = 0;
+    let nextGroupId = 0;
+    const conservativeEffects = () => ({
+        mayError: LANGUAGE_MAY_EFFECT.mayError,
+        mayInvokeMetamethod: options.runtime?.semantics.mutableMetatables === false
+            ? {
+                value: "no",
+                evidence: {
+                    kind: "runtime",
+                    profile: options.runtime.profile,
+                    reason: "runtime-has-no-mutable-metatables",
+                },
+            }
+            : LANGUAGE_MAY_EFFECT.mayInvokeMetamethod,
+    });
+    const record = (operation) => {
+        const sourceRange = operation.origin
+            .range;
+        const complete = {
+            ...operation,
+            ...(sourceRange ? { sourceRange } : {}),
+            id: nextOperationId++,
+        };
+        operations.push(complete);
+        if ("location" in complete && complete.location.kind === "external") {
+            unknowns.push({
+                origin: complete.origin,
+                domain: "location",
+                reason: complete.location.reason,
+            });
+        }
+        byOrigin.set(complete.origin, complete);
+        const owned = byOwner.get(complete.owner) ?? [];
+        owned.push(complete);
+        byOwner.set(complete.owner, owned);
+        if ("location" in complete &&
+            (complete.location.kind === "local" ||
+                complete.location.kind === "parameter" ||
+                complete.location.kind === "upvalue")) {
+            const symbolOperations = bySymbol.get(complete.location.symbol) ?? [];
+            symbolOperations.push(complete);
+            bySymbol.set(complete.location.symbol, symbolOperations);
+        }
+    };
+    function nearestFunctionScope(scope) {
+        for (let current = scope; current; current = current.parent) {
+            if (current.kind === "function")
+                return current;
+        }
+        return undefined;
+    }
+    function bindingLocation(identifier, currentFunction) {
+        const symbol = resolved.symbolOf(identifier);
+        if (symbol) {
+            if (nearestFunctionScope(symbol.scope) !== currentFunction)
+                return { kind: "upvalue", symbol };
+            if (symbol.kind === "param")
+                return { kind: "parameter", symbol };
+            return { kind: "local", symbol };
+        }
+        if (resolved.isGlobalReference(identifier)) {
+            const binding = resolved.globals.get(identifier.name);
+            if (binding)
+                return { kind: "global", binding };
+        }
+        return { kind: "external", reason: "unresolved-identifier" };
+    }
+    function tableLocation(expression) {
+        let key = { kind: "dynamic" };
+        if (expression.type === "MemberExpression") {
+            key = {
+                kind: "static",
+                value: (0, luaString_1.luaByteStringKey)((0, luaString_1.luaByteStringOfText)(expression.identifier.name)),
+            };
+        }
+        else if (expression.index.type === "StringLiteral") {
+            const decoded = (0, luaString_1.decodeLuaStringLiteral)(expression.index);
+            if (decoded.ok)
+                key = { kind: "static", value: (0, luaString_1.luaByteStringKey)(decoded.value) };
+        }
+        return { kind: "table", base: expression.base, key };
+    }
+    function effectsOf(expression) {
+        switch (expression.type) {
+            case "NilLiteral":
+            case "BooleanLiteral":
+            case "NumericLiteral":
+            case "StringLiteral":
+            case "VarargLiteral":
+            case "Identifier":
+            case "FunctionDeclaration":
+                return LANGUAGE_NO_EFFECT;
+            case "TableConstructorExpression":
+                return mergeEffects(expression.fields.flatMap((field) => [
+                    ...(field.type === "TableKey" ? [field.key] : []),
+                    field.value,
+                ]));
+            case "UnaryExpression":
+                return expression.operator === "-" &&
+                    expression.argument.type === "NumericLiteral"
+                    ? LANGUAGE_NO_EFFECT
+                    : conservativeEffects();
+            default:
+                return conservativeEffects();
+        }
+    }
+    function mergeEffects(expressions) {
+        const effects = expressions.map(effectsOf);
+        return {
+            mayError: effects.find((effect) => effect.mayError.value === "may")?.mayError ??
+                LANGUAGE_NO_EFFECT.mayError,
+            mayInvokeMetamethod: effects.find((effect) => effect.mayInvokeMetamethod.value === "may")
+                ?.mayInvokeMetamethod ?? LANGUAGE_NO_EFFECT.mayInvokeMetamethod,
+        };
+    }
+    function cardinalityOf(expression) {
+        switch (expression.type) {
+            case "CallExpression":
+            case "TableCallExpression":
+            case "StringCallExpression":
+            case "VarargLiteral":
+                return { kind: "tuple", knownPrefixLength: 0, tail: "unknown" };
+            default:
+                return { kind: "single" };
+        }
+    }
+    function valueOf(expression) {
+        switch (expression.type) {
+            case "NilLiteral":
+                return { kind: "nil" };
+            case "BooleanLiteral":
+                return { kind: "boolean", value: expression.value };
+            case "NumericLiteral":
+                return { kind: "number", raw: expression.raw };
+            case "StringLiteral":
+                return { kind: "string", raw: expression.raw };
+            case "TableConstructorExpression":
+                return {
+                    kind: "allocation",
+                    allocationKind: "table",
+                    origin: expression,
+                };
+            case "FunctionDeclaration":
+                return {
+                    kind: "allocation",
+                    allocationKind: "function",
+                    origin: expression,
+                };
+            case "Identifier":
+                return bindingLocation(expression, undefined).kind === "global"
+                    ? { kind: "external", reason: "global-binding" }
+                    : { kind: "unknown", reason: "binding-value-requires-flow" };
+            case "CallExpression":
+            case "TableCallExpression":
+            case "StringCallExpression":
+                return { kind: "unknown", reason: "call-result" };
+            case "VarargLiteral":
+                return { kind: "unknown", reason: "vararg-value" };
+            default:
+                return { kind: "unknown", reason: "computed-expression" };
+        }
+    }
+    function recordValueSlots(owner, expressions, targetCount) {
+        const slots = [];
+        const last = expressions.at(-1);
+        const lastExpands = last !== undefined && cardinalityOf(last).kind === "tuple";
+        for (let index = 0; index < targetCount; index++) {
+            if (index < expressions.length - 1 ||
+                (index < expressions.length && !lastExpands)) {
+                slots.push({
+                    index,
+                    source: { kind: "expression", expression: expressions[index] },
+                });
+            }
+            else if (last && lastExpands && index >= expressions.length - 1) {
+                slots.push({
+                    index,
+                    source: {
+                        kind: "tail-expansion",
+                        expression: last,
+                        offset: index - (expressions.length - 1),
+                    },
+                });
+            }
+            else {
+                slots.push({ index, source: { kind: "nil-padding" } });
+            }
+        }
+        valueSlots.set(owner, slots);
+    }
+    function visitExpression(expression, owner, currentFunction, group) {
+        const value = valueOf(expression);
+        const cardinality = cardinalityOf(expression);
+        expressionFacts.set(expression, {
+            expression,
+            value,
+            cardinality,
+            effects: effectsOf(expression),
+        });
+        if (value.kind === "unknown") {
+            unknowns.push({
+                origin: expression,
+                domain: "value",
+                reason: value.reason,
+            });
+        }
+        if (cardinality.kind === "unknown") {
+            unknowns.push({
+                origin: expression,
+                domain: "cardinality",
+                reason: cardinality.reason,
+            });
+        }
+        const position = { group, ordering: "unordered" };
+        switch (expression.type) {
+            case "Identifier":
+                record({
+                    kind: "read",
+                    location: bindingLocation(expression, currentFunction),
+                    owner,
+                    origin: expression,
+                    position,
+                });
+                return;
+            case "NilLiteral":
+            case "BooleanLiteral":
+            case "NumericLiteral":
+            case "StringLiteral":
+            case "VarargLiteral":
+                return;
+            case "UnaryExpression":
+                visitExpression(expression.argument, owner, currentFunction, group);
+                return;
+            case "BinaryExpression":
+            case "LogicalExpression":
+                visitExpression(expression.left, owner, currentFunction, group);
+                visitExpression(expression.right, owner, currentFunction, group);
+                return;
+            case "TableConstructorExpression":
+                record({
+                    kind: "allocate",
+                    allocationKind: "table",
+                    owner,
+                    origin: expression,
+                    position,
+                });
+                expression.fields.forEach((field) => {
+                    if (field.type === "TableKey")
+                        visitExpression(field.key, owner, currentFunction, group);
+                    visitExpression(field.value, owner, currentFunction, group);
+                });
+                return;
+            case "FunctionDeclaration":
+                record({
+                    kind: "allocate",
+                    allocationKind: "function",
+                    owner,
+                    origin: expression,
+                    position,
+                });
+                visitFunction(expression);
+                return;
+            case "MemberExpression":
+            case "IndexExpression": {
+                visitExpression(expression.base, owner, currentFunction, group);
+                if (expression.type === "IndexExpression")
+                    visitExpression(expression.index, owner, currentFunction, group);
+                record({
+                    kind: "table-read",
+                    location: tableLocation(expression),
+                    owner,
+                    origin: expression,
+                    position,
+                });
+                return;
+            }
+            case "CallExpression":
+            case "TableCallExpression":
+            case "StringCallExpression": {
+                visitExpression(expression.base, owner, currentFunction, group);
+                if (expression.type === "CallExpression")
+                    expression.arguments.forEach((argument) => {
+                        visitExpression(argument, owner, currentFunction, group);
+                    });
+                else
+                    visitExpression(expression.type === "TableCallExpression"
+                        ? expression.arguments
+                        : expression.argument, owner, currentFunction, group);
+                const target = expression.base.type === "Identifier"
+                    ? bindingLocation(expression.base, currentFunction)
+                    : { kind: "unknown" };
+                record({
+                    kind: "call",
+                    call: expression,
+                    target,
+                    owner,
+                    origin: expression,
+                    position,
+                });
+                return;
+            }
+        }
+    }
+    function declare(identifier, owner, currentFunction, group) {
+        record({
+            kind: "declare",
+            location: bindingLocation(identifier, currentFunction),
+            owner,
+            origin: identifier,
+            position: { group, ordering: "sequenced" },
+        });
+    }
+    function visitFunction(fn) {
+        const functionScope = resolved.scopeOfFunction(fn);
+        const owner = fn;
+        fn.parameters.forEach((parameter) => {
+            if (parameter.type === "Identifier")
+                declare(parameter, owner, functionScope, nextGroupId++);
+        });
+        visitBlock(fn.body, functionScope);
+    }
+    function visitStatementContents(statement, currentFunction) {
+        const group = nextGroupId++;
+        const expressions = (items) => {
+            items.forEach((item) => {
+                visitExpression(item, statement, currentFunction, group);
+            });
+        };
+        switch (statement.type) {
+            case "LocalStatement":
+                expressions(statement.init);
+                recordValueSlots(statement, statement.init, statement.variables.length);
+                statement.variables.forEach((id) => {
+                    declare(id, statement, currentFunction, group);
+                });
+                return;
+            case "AssignmentStatement":
+                expressions(statement.init);
+                recordValueSlots(statement, statement.init, statement.variables.length);
+                statement.variables.forEach((target) => {
+                    if (target.type === "Identifier")
+                        record({
+                            kind: "write",
+                            location: bindingLocation(target, currentFunction),
+                            owner: statement,
+                            origin: target,
+                            position: { group, ordering: "unordered" },
+                        });
+                    else {
+                        visitExpression(target.base, statement, currentFunction, group);
+                        if (target.type === "IndexExpression")
+                            visitExpression(target.index, statement, currentFunction, group);
+                        record({
+                            kind: "table-write",
+                            location: tableLocation(target),
+                            owner: statement,
+                            origin: target,
+                            position: { group, ordering: "unordered" },
+                        });
+                    }
+                });
+                return;
+            case "CallStatement":
+                visitExpression(statement.expression, statement, currentFunction, group);
+                return;
+            case "ReturnStatement":
+                expressions(statement.arguments);
+                return;
+            case "WhileStatement":
+                visitExpression(statement.condition, statement, currentFunction, group);
+                visitBlock(statement.body, currentFunction);
+                return;
+            case "RepeatStatement":
+                visitBlock(statement.body, currentFunction);
+                visitExpression(statement.condition, statement, currentFunction, group);
+                return;
+            case "DoStatement":
+                visitBlock(statement.body, currentFunction);
+                return;
+            case "IfStatement":
+                statement.clauses.forEach((clause) => {
+                    if (clause.type !== "ElseClause")
+                        visitExpression(clause.condition, statement, currentFunction, group);
+                    visitBlock(clause.body, currentFunction);
+                });
+                return;
+            case "ForNumericStatement":
+                expressions([
+                    statement.start,
+                    statement.end,
+                    ...(statement.step ? [statement.step] : []),
+                ]);
+                declare(statement.variable, statement, currentFunction, group);
+                visitBlock(statement.body, currentFunction);
+                return;
+            case "ForGenericStatement":
+                expressions(statement.iterators);
+                statement.variables.forEach((id) => {
+                    declare(id, statement, currentFunction, group);
+                });
+                visitBlock(statement.body, currentFunction);
+                return;
+            case "FunctionDeclaration":
+                if (statement.identifier) {
+                    if (statement.identifier.type === "Identifier")
+                        record({
+                            kind: statement.isLocal ? "declare" : "write",
+                            location: bindingLocation(statement.identifier, currentFunction),
+                            owner: statement,
+                            origin: statement.identifier,
+                            position: { group, ordering: "sequenced" },
+                        });
+                    else {
+                        visitExpression(statement.identifier.base, statement, currentFunction, group);
+                        record({
+                            kind: "table-write",
+                            location: tableLocation(statement.identifier),
+                            owner: statement,
+                            origin: statement.identifier,
+                            position: { group, ordering: "unordered" },
+                        });
+                    }
+                }
+                record({
+                    kind: "allocate",
+                    allocationKind: "function",
+                    owner: statement,
+                    origin: statement,
+                    position: { group, ordering: "sequenced" },
+                });
+                visitFunction(statement);
+                return;
+            case "BreakStatement":
+            case "LabelStatement":
+            case "GotoStatement":
+                return;
+        }
+    }
+    function visitStatement(statement, currentFunction) {
+        const operationStart = operations.length;
+        visitStatementContents(statement, currentFunction);
+        withinOwner.set(statement, operations.slice(operationStart));
+    }
+    function visitBlock(body, currentFunction) {
+        body.forEach((statement) => {
+            visitStatement(statement, currentFunction);
+        });
+    }
+    visitBlock(chunk.body, undefined);
+    return {
+        generation: options.generation ?? 0,
+        policy: {
+            runtime: options.runtime,
+            assumptions: new Map(options.assumptions ?? []),
+        },
+        operations,
+        unknowns,
+        operationsOf: (owner) => byOwner.get(owner) ?? [],
+        operationsWithin: (owner) => withinOwner.get(owner) ?? [],
+        operationOf: (origin) => byOrigin.get(origin),
+        operationsOfSymbol: (symbol) => bySymbol.get(symbol) ?? [],
+        expressionFact: (expression) => expressionFacts.get(expression),
+        valueSlotsOf: (owner) => valueSlots.get(owner) ?? [],
+        discardabilityOf: (expression) => {
+            const fact = expressionFacts.get(expression);
+            if (!fact)
+                return { discardable: false, reason: "expression-unindexed" };
+            if (fact.effects.mayError.value === "may" ||
+                fact.effects.mayInvokeMetamethod.value === "may") {
+                return { discardable: false, reason: "observable-effect" };
+            }
+            const syntacticallyDiscardable = expression.type === "NilLiteral" ||
+                expression.type === "BooleanLiteral" ||
+                expression.type === "NumericLiteral" ||
+                expression.type === "StringLiteral" ||
+                expression.type === "FunctionDeclaration" ||
+                (expression.type === "UnaryExpression" &&
+                    expression.operator === "-" &&
+                    expression.argument.type === "NumericLiteral");
+            return syntacticallyDiscardable
+                ? {
+                    discardable: true,
+                    evidence: { kind: "language", reason: "nonobserving-value" },
+                }
+                : { discardable: false, reason: "value-or-allocation-observable" };
+        },
+    };
+}