storm-lua-minify 0.3.0 → 0.9.1

package/dist/transform.js

@@ -1,55 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeLocalDeclarations = mergeLocalDeclarations;
 exports.originalNameOf = originalNameOf;
 exports.insertGlobalAliases = insertGlobalAliases;
 const linker_1 = require("./linker");
-function mergeLocalDeclarations(chunk, resolveResult, options) {
-    processBlock(chunk.body, resolveResult, options);
-}
-// 十分に非現実的な接頭辞を使い、実在の識別子との衝突を避ける
-// （このパスの直後にresolveScopesが再実行され、最終的な短縮名は
-// Renameパスが決めるため、この仮名自体が出力に残ることはない）。
 const ALIAS_TEMP_NAME_PREFIX = "__mergeAlias";
-// エイリアス化で`.name`を書き換えた参照ノードについて、Source Mapに載せる
-// べき「元の名前」を記録する。ast2lua.tsのgenerateIdentifierはこれを参照し、
-// 位置情報(loc)はそのままなのにSource Mapのnamesフィールドだけ書き換え後の
-// 仮名（あるいは最終的な短縮名）になってしまう不具合を避ける。
 const aliasedOriginalNames = new WeakMap();
 function originalNameOf(identifier) {
     return aliasedOriginalNames.get(identifier);
 }
-// 代入コスト（`local X=`相当、8バイト）を、参照1回あたりの節約バイト数
-// （元の名前の長さ-1文字、エイリアス名を1文字と仮定）で上回るかどうかで判定する。
 function isWorthAliasing(name, referenceCount) {
     const savingsPerReference = name.length - 1;
     const declarationCost = 8 + name.length;
     return referenceCount * savingsPerReference > declarationCost;
 }
+/** Inserts aliases for profitable read-only external globals before statement scheduling. */
 function insertGlobalAliases(chunk, resolveResult, options) {
     const newLocals = [];
     let aliasCounter = 0;
     resolveResult.globals.forEach((binding) => {
-        // 一度でも代入されているグローバルは#8aが直接リネームする対象（か、そちらが
-        // 保護対象として保持する）なので、ここでの対象は代入が一度もないものに限る。
-        if (binding.writes.length > 0) {
-            return;
-        }
-        if (options.excludeNames.has(binding.name)) {
-            return;
-        }
-        // require/dofileはPrintパスが名前文字列で再検出するため、
-        // エイリアス化して名前を変えると検出できなくなり壊れる。
-        if (linker_1.RESERVED_MODULE_FUNCTION_NAMES.has(binding.name)) {
+        if (binding.writes.length > 0 ||
+            options.excludeNames.has(binding.name) ||
+            linker_1.RESERVED_MODULE_FUNCTION_NAMES.has(binding.name) ||
+            !isWorthAliasing(binding.name, binding.references.length))
             return;
-        }
-        if (!isWorthAliasing(binding.name, binding.references.length)) {
-            return;
-        }
         const tempName = ALIAS_TEMP_NAME_PREFIX + String(aliasCounter++);
-        binding.references.forEach((ref) => {
-            aliasedOriginalNames.set(ref, ref.name);
-            ref.name = tempName;
+        binding.references.forEach((reference) => {
+            aliasedOriginalNames.set(reference, reference.name);
+            reference.name = tempName;
         });
         newLocals.push({
             type: "LocalStatement",
@@ -57,345 +34,7 @@ function insertGlobalAliases(chunk, resolveResult, options) {
             init: [{ type: "Identifier", name: binding.name }],
         });
     });
-    if (newLocals.length > 0) {
+    if (newLocals.length > 0)
         chunk.body.unshift(...newLocals);
-    }
-}
-// resolver.tsのresolveStatement/resolveExpressionの分岐を鏡写しにした
-// 汎用ウォーカー。「参照として現れる識別子」と「ネストしたブロック本体」を
-// どちらも一度の走査で収集できるようにし、resolver.tsの走査ロジックの
-// 重複を避ける。
-function walkStatement(statement, visitor) {
-    switch (statement.type) {
-        case "LocalStatement":
-            // 宣言される変数自体は参照ではないため辿らない
-            statement.init.forEach((expr) => {
-                walkExpression(expr, visitor);
-            });
-            return;
-        case "AssignmentStatement":
-            statement.variables.forEach((v) => {
-                if (v.type === "Identifier") {
-                    visitor.onIdentifierReference?.(v);
-                }
-                else {
-                    walkExpression(v, visitor);
-                }
-            });
-            statement.init.forEach((expr) => {
-                walkExpression(expr, visitor);
-            });
-            return;
-        case "CallStatement":
-            walkExpression(statement.expression, visitor);
-            return;
-        case "DoStatement":
-            visitor.onBlock?.(statement.body);
-            return;
-        case "WhileStatement":
-            walkExpression(statement.condition, visitor);
-            visitor.onBlock?.(statement.body);
-            return;
-        case "RepeatStatement":
-            visitor.onBlock?.(statement.body);
-            walkExpression(statement.condition, visitor);
-            return;
-        case "IfStatement":
-            statement.clauses.forEach((clause) => {
-                if (clause.type !== "ElseClause") {
-                    walkExpression(clause.condition, visitor);
-                }
-                visitor.onBlock?.(clause.body);
-            });
-            return;
-        case "ForNumericStatement":
-            walkExpression(statement.start, visitor);
-            walkExpression(statement.end, visitor);
-            if (statement.step) {
-                walkExpression(statement.step, visitor);
-            }
-            visitor.onBlock?.(statement.body);
-            return;
-        case "ForGenericStatement":
-            statement.iterators.forEach((iterator) => {
-                walkExpression(iterator, visitor);
-            });
-            visitor.onBlock?.(statement.body);
-            return;
-        case "FunctionDeclaration":
-            if (statement.identifier) {
-                if (statement.identifier.type === "Identifier") {
-                    if (!statement.isLocal) {
-                        // 非local: 既存のローカル/グローバルへの代入（参照扱い）
-                        visitor.onIdentifierReference?.(statement.identifier);
-                    }
-                    // isLocalの場合は宣言自体であり参照ではないため辿らない
-                }
-                else {
-                    walkExpression(statement.identifier, visitor);
-                }
-            }
-            visitor.onBlock?.(statement.body);
-            return;
-        case "ReturnStatement":
-            statement.arguments.forEach((argument) => {
-                walkExpression(argument, visitor);
-            });
-            return;
-        case "BreakStatement":
-        case "LabelStatement":
-        case "GotoStatement":
-            return;
-        default: {
-            const exhaustive = statement;
-            throw new TypeError("Unknown statement type: `" + JSON.stringify(exhaustive) + "`");
-        }
-    }
-}
-function walkExpression(expr, visitor) {
-    switch (expr.type) {
-        case "Identifier":
-            visitor.onIdentifierReference?.(expr);
-            return;
-        case "StringLiteral":
-        case "NumericLiteral":
-        case "BooleanLiteral":
-        case "NilLiteral":
-        case "VarargLiteral":
-            return;
-        case "LogicalExpression":
-        case "BinaryExpression":
-            walkExpression(expr.left, visitor);
-            walkExpression(expr.right, visitor);
-            return;
-        case "UnaryExpression":
-            walkExpression(expr.argument, visitor);
-            return;
-        case "CallExpression":
-            walkExpression(expr.base, visitor);
-            expr.arguments.forEach((argument) => {
-                walkExpression(argument, visitor);
-            });
-            return;
-        case "TableCallExpression":
-            walkExpression(expr.base, visitor);
-            walkExpression(expr.arguments, visitor);
-            return;
-        case "StringCallExpression":
-            walkExpression(expr.base, visitor);
-            walkExpression(expr.argument, visitor);
-            return;
-        case "IndexExpression":
-            walkExpression(expr.base, visitor);
-            walkExpression(expr.index, visitor);
-            return;
-        case "MemberExpression":
-            walkExpression(expr.base, visitor);
-            // フィールド名（`.identifier`）は変数参照ではないため辿らない
-            return;
-        case "FunctionDeclaration":
-            visitor.onBlock?.(expr.body);
-            return;
-        case "TableConstructorExpression":
-            expr.fields.forEach((field) => {
-                if (field.type === "TableKey") {
-                    walkExpression(field.key, visitor);
-                    walkExpression(field.value, visitor);
-                }
-                else {
-                    walkExpression(field.value, visitor);
-                }
-            });
-            return;
-        default: {
-            const exhaustive = expr;
-            throw new TypeError("Unknown expression type: `" + JSON.stringify(exhaustive) + "`");
-        }
-    }
-}
-function processBlock(body, resolveResult, options) {
-    // 先に子ブロック（ネストしたスコープ）を処理する。子ブロックは別配列なので
-    // このレベルでのまとめ上げには影響しない。
-    body.forEach((statement) => {
-        walkStatement(statement, {
-            onBlock: (nested) => {
-                processBlock(nested, resolveResult, options);
-            },
-        });
-    });
-    mergeRunsInPlace(body, resolveResult, options);
-}
-// あるexpr（候補文のinit式）の中に現れる識別子参照をすべて収集する。
-// ネストした関数リテラルの本体も再帰的に辿る（ハザード1: クロージャの
-// 字句スコープは実行タイミングに関わらず即座に確定するため）。
-function collectIdentifierReferences(expr) {
-    const found = [];
-    const visitor = {
-        onIdentifierReference: (id) => found.push(id),
-        onBlock: (body) => {
-            body.forEach((s) => {
-                walkStatement(s, visitor);
-            });
-        },
-    };
-    walkExpression(expr, visitor);
-    return found;
-}
-// ============================================================
-// ハザード判定
-// ============================================================
-function isExpandable(expr) {
-    return (expr.type === "CallExpression" ||
-        expr.type === "TableCallExpression" ||
-        expr.type === "StringCallExpression" ||
-        expr.type === "VarargLiteral");
-}
-// ハザード2（複数値展開）: statementをグループの非末尾要素として
-// 後ろに文を連結してよいかどうかを判定する。
-//   - 変数と初期化式の個数が一致: 常に安全（パディング不要）
-//   - 変数が多い（不足）: 最後の初期化式が展開可能でなければnilパディングで安全。
-//     展開可能な式に依存している場合は非末尾にできない。
-//   - 初期化式が多い（過剰）: 常に非末尾として不安全
-//     （余剰の値が後続文の変数へずれ込むため、パディングでは救えない）
-function classifyNonTerminal(statement) {
-    const varCount = statement.variables.length;
-    const initCount = statement.init.length;
-    if (varCount === initCount) {
-        return { safe: true, needsPadding: false };
-    }
-    if (varCount > initCount) {
-        const lastInit = initCount > 0 ? statement.init[initCount - 1] : undefined;
-        if (!lastInit || !isExpandable(lastInit)) {
-            return { safe: true, needsPadding: true };
-        }
-        return { safe: false };
-    }
-    return { safe: false };
-}
-// ハザード1（参照順序）: candidateのinit式が、groupSoFarで宣言済みの
-// 変数を参照していないかを判定する。参照していれば統合するとLuaの
-// スコープ規則上意味が変わってしまうため、そこでグループを閉じる必要がある。
-function initReferencesDeclaredInGroup(candidate, groupSoFar, resolveResult) {
-    const declaredInGroup = new Set();
-    groupSoFar.forEach((statement) => {
-        statement.variables.forEach((v) => {
-            const symbol = resolveResult.symbolOf(v);
-            if (symbol) {
-                declaredInGroup.add(symbol);
-            }
-        });
-    });
-    return candidate.init.some((expr) => collectIdentifierReferences(expr).some((id) => {
-        const symbol = resolveResult.symbolOf(id);
-        return symbol !== undefined && declaredInGroup.has(symbol);
-    }));
-}
-// ハザード4: SLモードでtrySpliceRequireStatement（#29）の対象になり得る
-// `local x = require(<静的文字列>)`形式の文かどうかを判定する。
-function isSpliceEligibleRequire(statement) {
-    if (statement.variables.length !== 1 || statement.init.length !== 1) {
-        return false;
-    }
-    return isStaticRequireCall(statement.init[0]);
-}
-function isStaticRequireCall(expr) {
-    if (expr.type === "CallExpression") {
-        return (expr.base.type === "Identifier" &&
-            expr.base.name === "require" &&
-            expr.arguments.length > 0 &&
-            (0, linker_1.staticStringArgument)(expr.arguments[0]) !== undefined);
-    }
-    if (expr.type === "StringCallExpression") {
-        return (expr.base.type === "Identifier" &&
-            expr.base.name === "require" &&
-            (0, linker_1.staticStringArgument)(expr.argument) !== undefined);
-    }
-    return false;
-}
-// ============================================================
-// グループ化とマージ
-// ============================================================
-function nilLiteral() {
-    return { type: "NilLiteral", value: null, raw: "nil" };
-}
-function combineGroup(group) {
-    const variables = [];
-    const init = [];
-    group.forEach((statement, index) => {
-        variables.push(...statement.variables);
-        const isLast = index === group.length - 1;
-        init.push(...statement.init);
-        if (!isLast) {
-            const safety = classifyNonTerminal(statement);
-            if (safety.safe && safety.needsPadding) {
-                const padCount = statement.variables.length - statement.init.length;
-                for (let i = 0; i < padCount; i++) {
-                    init.push(nilLiteral());
-                }
-            }
-        }
-    });
-    // 末尾の合成nilは、Luaが変数超過分を自動的にnilで埋めるため省略できる
-    // （元から書かれていた明示的なnilを末尾で省略しても意味は変わらない）。
-    while (init.length > 0 && init[init.length - 1].type === "NilLiteral") {
-        init.pop();
-    }
-    return {
-        type: "LocalStatement",
-        variables,
-        init,
-    };
-}
-function mergeRun(run, resolveResult, options) {
-    const output = [];
-    let groupStart = 0;
-    const flushGroup = (endExclusive) => {
-        if (endExclusive <= groupStart) {
-            return;
-        }
-        const group = run.slice(groupStart, endExclusive);
-        output.push(group.length >= 2 ? combineGroup(group) : group[0]);
-    };
-    for (let k = 0; k < run.length; k++) {
-        const statement = run[k];
-        if (options.preserveRequireSplice && isSpliceEligibleRequire(statement)) {
-            flushGroup(k);
-            output.push(statement);
-            groupStart = k + 1;
-            continue;
-        }
-        if (k === groupStart) {
-            continue;
-        }
-        const previous = run[k - 1];
-        const previousSafety = classifyNonTerminal(previous);
-        const referencesGroupLocal = initReferencesDeclaredInGroup(statement, run.slice(groupStart, k), resolveResult);
-        if (!previousSafety.safe || referencesGroupLocal) {
-            flushGroup(k);
-            groupStart = k;
-        }
-    }
-    flushGroup(run.length);
-    return output;
-}
-function mergeRunsInPlace(body, resolveResult, options) {
-    const result = [];
-    let i = 0;
-    while (i < body.length) {
-        const statement = body[i];
-        if (statement.type !== "LocalStatement") {
-            result.push(statement);
-            i++;
-            continue;
-        }
-        let j = i;
-        const run = [];
-        while (j < body.length && body[j].type === "LocalStatement") {
-            run.push(body[j]);
-            j++;
-        }
-        result.push(...mergeRun(run, resolveResult, options));
-        i = j;
-    }
-    body.splice(0, body.length, ...result);
+    return newLocals.length > 0;
 }