storm-lua-minify 0.2.0 → 0.9.0

package/dist/removeUnused.js

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

package/dist/renamer.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAvailable = isAvailable;
+exports.generateCandidate = generateCandidate;
 exports.assignRenames = assignRenames;
+const resolver_1 = require("./resolver");
 const ast2lua_1 = require("./ast2lua");
+const controlFlow_1 = require("./controlFlow");
+const optimizerFacts_1 = require("./optimizerFacts");
+const symbolLiveness_1 = require("./symbolLiveness");
 function isAvailable(id, reserved) {
     return id !== "self" && !(0, ast2lua_1.isKeyword)(id) && !reserved.has(id);
 }
@@ -19,69 +25,246 @@ function generateCandidate(counter) {
     }
     return id;
 }
-/**
- * スコープ木のDFSでシンボルごとにスロット番号を割り当てる。
- * `active`は祖先スコープ（自分を含む）で既に使われているスロットの集合。
- * 兄弟スコープには同じ`active`のコピーが渡されるため、互いの割当は影響しない。
- */
-function assignSlots(scope, active) {
-    const slotOf = new Map();
-    const used = new Set(active);
-    scope.symbols.forEach((symbol) => {
-        let slot = 0;
-        while (used.has(slot)) {
-            slot++;
-        }
-        slotOf.set(symbol, slot);
-        used.add(slot);
+function assignRenames(chunk, resolveResult, reserved, 
+// #8a: プログラム全体を横断して決定されたグローバル識別子の短縮名。
+// 全モジュールに対して同じマップを渡すことで、モジュールをまたいで
+// 共有される1つのランタイム束縛に一貫した短縮名を割り当てられる。
+globalRenames, keepNames = new Set(), options = {}) {
+    const unavailableNames = new Set(reserved);
+    keepNames.forEach((symbol) => unavailableNames.add(symbol.name));
+    const variables = options.renameLocals === false
+        ? []
+        : resolveResult.symbols.filter((symbol) => symbol.kind !== "label" &&
+            !symbol.implicit &&
+            !keepNames.has(symbol));
+    const variableGraph = buildVariableInterference(chunk, resolveResult, variables, options.allowLocalNameReuse === true, options.analysis);
+    const variableColors = colorGraph(variableGraph);
+    const variableNames = assignColorNames(variableColors, unavailableNames);
+    // Labels have a separate Lua namespace. Color them independently so a label
+    // and a local may share a short spelling, while usedNames still reserves the
+    // spelling against labels from subsequently spliced modules.
+    const labels = options.renameLocals === false
+        ? []
+        : resolveResult.symbols.filter((symbol) => symbol.kind === "label" &&
+            symbol.name !== "self" &&
+            !keepNames.has(symbol));
+    const labelNames = assignColorNames(colorGraph(buildLexicalGraph(labels, false)), unavailableNames);
+    const nameOfSymbol = new Map([...variableNames, ...labelNames]);
+    validateBindings(chunk, resolveResult, nameOfSymbol, globalRenames);
+    const usedNames = new Set(nameOfSymbol.values());
+    return {
+        nameOf: (identifier) => {
+            // メソッド定義の暗黙のselfパラメータは慣習的な名前のため常に維持する
+            // （呼び出し側から見える名前ではないため短縮しても安全ではあるが、
+            // 可読性のために元の名前のままにする）。
+            if (identifier.name === "self") {
+                return undefined;
+            }
+            const symbol = resolveResult.symbolOf(identifier);
+            if (symbol) {
+                return nameOfSymbol.get(symbol);
+            }
+            // フィールド名（`.foo`）はここに来るが、これらはisGlobalReferenceが
+            // falseになるため名前文字列がたまたま一致しても誤ってリネームしない。
+            if (globalRenames && resolveResult.isGlobalReference(identifier)) {
+                return globalRenames.get(identifier.name);
+            }
+            return undefined;
+        },
+        usedNames,
+    };
+}
+function buildVariableInterference(chunk, resolved, symbols, allowLocalNameReuse, analysis) {
+    const graph = mutableGraph(symbols);
+    const facts = analysis?.facts ?? (0, optimizerFacts_1.analyzeOptimizerFacts)(chunk, resolved);
+    const liveness = analysis?.liveness ??
+        (0, symbolLiveness_1.analyzeSymbolLiveness)((0, controlFlow_1.analyzeControlFlow)(chunk, resolved), facts);
+    if (facts.generation !== liveness.controlFlow.version)
+        throw new Error("Identifier coloring requires one AST generation");
+    liveness.controlFlow.nodes.forEach((node) => {
+        addClique(graph, liveness.liveIn(node));
+        addClique(graph, liveness.liveOut(node));
+        liveness.defs(node).forEach((definition) => {
+            liveness.liveOut(node).forEach((live) => {
+                addEdge(graph, definition, live);
+            });
+        });
     });
-    scope.children.forEach((child) => {
-        assignSlots(child, used).forEach((slot, symbol) => {
-            slotOf.set(symbol, slot);
+    // Parameters, generic-for variables, and multi-local declarations bind as a
+    // group. Giving two members one spelling would make only the last binding
+    // addressable after reparsing even if one member happens to be unused.
+    const declarationsByOwner = new Map();
+    symbols.forEach((symbol) => {
+        const declaration = facts
+            .operationsOfSymbol(symbol)
+            .find((operation) => operation.kind === "declare" &&
+            operation.origin === symbol.declaration);
+        if (!declaration)
+            return;
+        const group = declarationsByOwner.get(declaration.owner) ?? [];
+        group.push(symbol);
+        declarationsByOwner.set(declaration.owner, group);
+    });
+    declarationsByOwner.forEach((group) => {
+        addClique(graph, group);
+    });
+    // A captured binding can be shadowed inside the closure by any same-scope
+    // declaration whose emitted spelling matches it (notably `local function`).
+    // Extending this lexical interference across the whole declaring scope is
+    // conservative, deterministic, and leaves ordinary non-captured locals free
+    // to reuse names according to liveness.
+    symbols.forEach((symbol) => {
+        const captured = facts
+            .operationsOfSymbol(symbol)
+            .some((operation) => "location" in operation && operation.location.kind === "upvalue");
+        if (!captured)
+            return;
+        symbols.forEach((other) => {
+            if (other.scope === symbol.scope)
+                addEdge(graph, symbol, other);
         });
     });
-    return slotOf;
+    addLexicalEdges(graph, symbols, allowLocalNameReuse);
+    return graph;
 }
-function assignRenames(resolveResult, reserved) {
-    const slotOf = assignSlots(resolveResult.chunkScope, new Set());
-    // スロットの通算参照回数（宣言自体も1回として数える）を集計する。
-    const weightOfSlot = new Map();
-    resolveResult.symbols.forEach((symbol) => {
-        const slot = slotOf.get(symbol);
-        if (slot === undefined) {
-            return;
+function buildLexicalGraph(symbols, allowSameScopeReuse) {
+    const graph = mutableGraph(symbols);
+    addLexicalEdges(graph, symbols, allowSameScopeReuse);
+    return graph;
+}
+function mutableGraph(symbols) {
+    return new Map(symbols.map((symbol) => [symbol, new Set()]));
+}
+function addLexicalEdges(graph, symbols, allowSameScopeReuse) {
+    for (let left = 0; left < symbols.length; left++) {
+        for (let right = left + 1; right < symbols.length; right++) {
+            const first = symbols[left];
+            const last = symbols[right];
+            if (isAncestor(first.scope, last.scope) ||
+                isAncestor(last.scope, first.scope) ||
+                (!allowSameScopeReuse && first.scope === last.scope))
+                addEdge(graph, first, last);
         }
-        const weight = symbol.references.length + 1;
-        weightOfSlot.set(slot, (weightOfSlot.get(slot) ?? 0) + weight);
+    }
+}
+function isAncestor(ancestor, descendant) {
+    if (ancestor === descendant)
+        return false;
+    for (let current = descendant.parent; current; current = current.parent)
+        if (current === ancestor)
+            return true;
+    return false;
+}
+function addClique(graph, symbols) {
+    const present = [...symbols].filter((symbol) => graph.has(symbol));
+    for (let left = 0; left < present.length; left++)
+        for (let right = left + 1; right < present.length; right++)
+            addEdge(graph, present[left], present[right]);
+}
+function addEdge(graph, first, last) {
+    if (first === last || !graph.has(first) || !graph.has(last))
+        return;
+    graph.get(first)?.add(last);
+    graph.get(last)?.add(first);
+}
+/** Deterministic weighted DSATUR coloring. */
+function colorGraph(graph) {
+    const colors = new Map();
+    while (colors.size < graph.size) {
+        const remaining = [...graph.keys()].filter((symbol) => !colors.has(symbol));
+        remaining.sort((left, right) => {
+            const saturationDifference = saturation(graph, colors, right) - saturation(graph, colors, left);
+            if (saturationDifference !== 0)
+                return saturationDifference;
+            const weightDifference = weightOf(right) - weightOf(left);
+            if (weightDifference !== 0)
+                return weightDifference;
+            const degreeDifference = (graph.get(right)?.size ?? 0) - (graph.get(left)?.size ?? 0);
+            return degreeDifference !== 0 ? degreeDifference : left.id - right.id;
+        });
+        const symbol = remaining[0];
+        const unavailable = new Set([...(graph.get(symbol) ?? [])].flatMap((neighbor) => {
+            const color = colors.get(neighbor);
+            return color === undefined ? [] : [color];
+        }));
+        let color = 0;
+        while (unavailable.has(color))
+            color++;
+        colors.set(symbol, color);
+    }
+    return colors;
+}
+function saturation(graph, colors, symbol) {
+    return new Set([...(graph.get(symbol) ?? [])].flatMap((neighbor) => {
+        const color = colors.get(neighbor);
+        return color === undefined ? [] : [color];
+    })).size;
+}
+function weightOf(symbol) {
+    return symbol.references.length + 1;
+}
+function assignColorNames(colors, reserved) {
+    const unavailable = new Set(reserved);
+    const weightByColor = new Map();
+    const firstSymbolByColor = new Map();
+    colors.forEach((color, symbol) => {
+        weightByColor.set(color, (weightByColor.get(color) ?? 0) + weightOf(symbol));
+        firstSymbolByColor.set(color, Math.min(firstSymbolByColor.get(color) ?? symbol.id, symbol.id));
     });
-    const orderedSlots = [...weightOfSlot.keys()].sort((a, b) => (weightOfSlot.get(b) ?? 0) - (weightOfSlot.get(a) ?? 0));
-    const nameOfSlot = new Map();
+    const orderedColors = [...weightByColor.keys()].sort((left, right) => (weightByColor.get(right) ?? 0) - (weightByColor.get(left) ?? 0) ||
+        (firstSymbolByColor.get(left) ?? 0) -
+            (firstSymbolByColor.get(right) ?? 0));
+    const nameByColor = new Map();
     let counter = 0;
-    orderedSlots.forEach((slot) => {
+    orderedColors.forEach((color) => {
         let candidate;
-        do {
+        do
             candidate = generateCandidate(counter++);
-        } while (!isAvailable(candidate, reserved));
-        nameOfSlot.set(slot, candidate);
+        while (!isAvailable(candidate, unavailable));
+        unavailable.add(candidate);
+        nameByColor.set(color, candidate);
     });
-    const nameOfSymbol = new Map();
-    slotOf.forEach((slot, symbol) => {
-        const name = nameOfSlot.get(slot);
-        if (name !== undefined) {
-            nameOfSymbol.set(symbol, name);
-        }
+    // Every candidate is an identifier token and keywords are excluded, so the
+    // separator cost around each occurrence is invariant across candidates.
+    // Occurrence count therefore gives the exact candidate-dependent byte cost.
+    const result = new Map();
+    colors.forEach((color, symbol) => {
+        const name = nameByColor.get(color);
+        if (name === undefined)
+            throw new Error("Colored symbol has no name");
+        result.set(symbol, name);
     });
-    return {
-        nameOf: (identifier) => {
-            // メソッド定義の暗黙のselfパラメータは慣習的な名前のため常に維持する
-            // （呼び出し側から見える名前ではないため短縮しても安全ではあるが、
-            // 可読性のために元の名前のままにする）。
-            if (identifier.name === "self") {
-                return undefined;
-            }
-            const symbol = resolveResult.symbolOf(identifier);
-            return symbol ? nameOfSymbol.get(symbol) : undefined;
+    return result;
+}
+function validateBindings(chunk, original, names, globalRenames) {
+    const recolored = (0, resolver_1.resolveScopes)(chunk, {
+        identifierName: (identifier) => {
+            const symbol = original.symbolOf(identifier);
+            if (symbol)
+                return names.get(symbol) ?? identifier.name;
+            return original.isGlobalReference(identifier)
+                ? (globalRenames?.get(identifier.name) ?? identifier.name)
+                : identifier.name;
         },
-        usedNames: new Set(nameOfSlot.values()),
-    };
+    });
+    original.symbols.forEach((symbol) => {
+        if (symbol.implicit) {
+            symbol.references.forEach((identifier) => {
+                const rebound = recolored.symbolOf(identifier);
+                if (!rebound?.implicit || rebound.name !== symbol.name)
+                    throw new Error(`Identifier coloring changed implicit binding for symbol ${String(symbol.id)}`);
+            });
+            return;
+        }
+        [symbol.declaration, ...symbol.references].forEach((identifier) => {
+            if (recolored.symbolOf(identifier)?.declaration !== symbol.declaration)
+                throw new Error(`Identifier coloring changed binding for symbol ${String(symbol.id)}`);
+        });
+    });
+    original.globals.forEach((binding) => {
+        binding.references.forEach((identifier) => {
+            if (!recolored.isGlobalReference(identifier))
+                throw new Error(`Identifier coloring captured global ${binding.name}`);
+        });
+    });
 }

package/dist/resolver.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveScopes = resolveScopes;
-function resolveScopes(chunk) {
+function resolveScopes(chunk, options = {}) {
     let nextSymbolId = 0;
     const allSymbols = [];
     const globals = new Map();
     const identifierSymbols = new WeakMap();
+    const globalReferenceNodes = new WeakSet();
+    const functionScopes = new WeakMap();
+    const identifierName = options.identifierName ??
+        ((identifier) => identifier.name);
     function createScope(kind, parent) {
         const scope = {
             kind,
@@ -18,33 +22,36 @@ function resolveScopes(chunk) {
         parent?.children.push(scope);
         return scope;
     }
-    function declare(scope, node, kind) {
+    function declare(scope, node, kind, implicit = false) {
+        const name = identifierName(node);
         const symbol = {
             id: nextSymbolId++,
-            name: node.name,
+            name,
             kind,
             scope,
             declaration: node,
             references: [],
+            ...(implicit ? { implicit: true } : {}),
         };
         // 同名の再宣言はスコープ内の以後の参照から見た束縛を上書きする（Luaの通常のシャドーイング）
         scope.symbols.push(symbol);
-        scope.bindings.set(node.name, symbol);
+        scope.bindings.set(name, symbol);
         allSymbols.push(symbol);
         identifierSymbols.set(node, symbol);
         return symbol;
     }
     function declareLabel(scope, node) {
+        const name = identifierName(node);
         const symbol = {
             id: nextSymbolId++,
-            name: node.name,
+            name,
             kind: "label",
             scope,
             declaration: node,
             references: [],
         };
         scope.symbols.push(symbol);
-        scope.labels.set(node.name, symbol);
+        scope.labels.set(name, symbol);
         allSymbols.push(symbol);
         identifierSymbols.set(node, symbol);
         return symbol;
@@ -67,19 +74,24 @@ function resolveScopes(chunk) {
         }
         return undefined;
     }
-    function reference(scope, node) {
-        const symbol = lookupBinding(scope, node.name);
+    function reference(scope, node, isWrite = false) {
+        const name = identifierName(node);
+        const symbol = lookupBinding(scope, name);
         if (symbol) {
             symbol.references.push(node);
             identifierSymbols.set(node, symbol);
             return;
         }
-        let binding = globals.get(node.name);
+        let binding = globals.get(name);
         if (!binding) {
-            binding = { name: node.name, references: [] };
-            globals.set(node.name, binding);
+            binding = { name, references: [], writes: [] };
+            globals.set(name, binding);
         }
         binding.references.push(node);
+        if (isWrite) {
+            binding.writes.push(node);
+        }
+        globalReferenceNodes.add(node);
     }
     // ラベルはブロック内での宣言位置に関わらずブロック全体から参照できる
     // （前方goto）ため、通常の宣言文と違い先読みで登録する。
@@ -112,7 +124,7 @@ function resolveScopes(chunk) {
                 });
                 statement.variables.forEach((v) => {
                     if (v.type === "Identifier") {
-                        reference(scope, v);
+                        reference(scope, v, true);
                     }
                     else {
                         resolveExpression(v, scope);
@@ -183,7 +195,7 @@ function resolveScopes(chunk) {
                 // hoistLabelsで宣言済みのため、ここでは何もしない
                 return;
             case "GotoStatement": {
-                const symbol = lookupLabel(scope, statement.label.name);
+                const symbol = lookupLabel(scope, identifierName(statement.label));
                 if (symbol) {
                     symbol.references.push(statement.label);
                     identifierSymbols.set(statement.label, symbol);
@@ -205,7 +217,7 @@ function resolveScopes(chunk) {
                 }
                 else {
                     // 非local: 既存のローカル/グローバルへの代入として扱う（新規宣言ではない）
-                    reference(scope, fn.identifier);
+                    reference(scope, fn.identifier, true);
                 }
             }
             else {
@@ -213,6 +225,14 @@ function resolveScopes(chunk) {
             }
         }
         const inner = createScope("function", scope);
+        functionScopes.set(fn, inner);
+        if (fn.identifier?.type === "MemberExpression" &&
+            fn.identifier.indexer === ":") {
+            // `function object:method(...)` declares an implicit first parameter. It has no
+            // declaration token in the AST, but it must still own every `self` reference so
+            // global analysis, aliases, summaries, and binding validation share Lua's binding.
+            declare(inner, { type: "Identifier", name: "self" }, "param", true);
+        }
         fn.parameters.forEach((parameter) => {
             if (parameter.type === "Identifier") {
                 declare(inner, parameter, "param");
@@ -263,6 +283,7 @@ function resolveScopes(chunk) {
                 return;
             case "FunctionDeclaration": {
                 const inner = createScope("function", scope);
+                functionScopes.set(expr, inner);
                 expr.parameters.forEach((parameter) => {
                     if (parameter.type === "Identifier") {
                         declare(inner, parameter, "param");
@@ -299,5 +320,7 @@ function resolveScopes(chunk) {
         symbols: allSymbols,
         globals,
         symbolOf: (identifier) => identifierSymbols.get(identifier),
+        isGlobalReference: (identifier) => globalReferenceNodes.has(identifier),
+        scopeOfFunction: (fn) => functionScopes.get(fn),
     };
 }