storm-lua-minify 0.1.3 → 0.3.0

package/dist/renamer.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAvailable = isAvailable;
+exports.generateCandidate = generateCandidate;
+exports.assignRenames = assignRenames;
+const ast2lua_1 = require("./ast2lua");
+function isAvailable(id, reserved) {
+    return id !== "self" && !(0, ast2lua_1.isKeyword)(id) && !reserved.has(id);
+}
+// 0始まりのカウンタから短縮名候補を生成する（バイジェクティブ基数記数法）。
+// 通常の位取り記数法と違い同じ文字列を2つのカウンタ値が指すことがないため、
+// カウンタを増やし続けるだけで重複なく識別子候補を列挙できる。
+function generateCandidate(counter) {
+    const l = ast2lua_1.IDENTIFIER_PARTS.length;
+    let num = counter + 1;
+    let id = "";
+    while (num > 0) {
+        const rem = (num - 1) % l;
+        id = ast2lua_1.IDENTIFIER_PARTS[rem] + id;
+        num = Math.floor((num - 1) / l);
+    }
+    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);
+    });
+    scope.children.forEach((child) => {
+        assignSlots(child, used).forEach((slot, symbol) => {
+            slotOf.set(symbol, slot);
+        });
+    });
+    return slotOf;
+}
+function assignRenames(resolveResult, reserved, 
+// #8a: プログラム全体を横断して決定されたグローバル識別子の短縮名。
+// 全モジュールに対して同じマップを渡すことで、モジュールをまたいで
+// 共有される1つのランタイム束縛に一貫した短縮名を割り当てられる。
+globalRenames) {
+    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;
+        }
+        const weight = symbol.references.length + 1;
+        weightOfSlot.set(slot, (weightOfSlot.get(slot) ?? 0) + weight);
+    });
+    const orderedSlots = [...weightOfSlot.keys()].sort((a, b) => (weightOfSlot.get(b) ?? 0) - (weightOfSlot.get(a) ?? 0));
+    const nameOfSlot = new Map();
+    let counter = 0;
+    orderedSlots.forEach((slot) => {
+        let candidate;
+        do {
+            candidate = generateCandidate(counter++);
+        } while (!isAvailable(candidate, reserved));
+        nameOfSlot.set(slot, candidate);
+    });
+    const nameOfSymbol = new Map();
+    slotOf.forEach((slot, symbol) => {
+        const name = nameOfSlot.get(slot);
+        if (name !== undefined) {
+            nameOfSymbol.set(symbol, name);
+        }
+    });
+    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: new Set(nameOfSlot.values()),
+    };
+}

package/dist/resolver.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveScopes = resolveScopes;
+function resolveScopes(chunk) {
+    let nextSymbolId = 0;
+    const allSymbols = [];
+    const globals = new Map();
+    const identifierSymbols = new WeakMap();
+    const globalReferenceNodes = new WeakSet();
+    function createScope(kind, parent) {
+        const scope = {
+            kind,
+            parent,
+            children: [],
+            symbols: [],
+            bindings: new Map(),
+            labels: new Map(),
+        };
+        parent?.children.push(scope);
+        return scope;
+    }
+    function declare(scope, node, kind) {
+        const symbol = {
+            id: nextSymbolId++,
+            name: node.name,
+            kind,
+            scope,
+            declaration: node,
+            references: [],
+        };
+        // 同名の再宣言はスコープ内の以後の参照から見た束縛を上書きする（Luaの通常のシャドーイング）
+        scope.symbols.push(symbol);
+        scope.bindings.set(node.name, symbol);
+        allSymbols.push(symbol);
+        identifierSymbols.set(node, symbol);
+        return symbol;
+    }
+    function declareLabel(scope, node) {
+        const symbol = {
+            id: nextSymbolId++,
+            name: node.name,
+            kind: "label",
+            scope,
+            declaration: node,
+            references: [],
+        };
+        scope.symbols.push(symbol);
+        scope.labels.set(node.name, symbol);
+        allSymbols.push(symbol);
+        identifierSymbols.set(node, symbol);
+        return symbol;
+    }
+    function lookupBinding(scope, name) {
+        for (let s = scope; s; s = s.parent) {
+            const found = s.bindings.get(name);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    function lookupLabel(scope, name) {
+        for (let s = scope; s; s = s.parent) {
+            const found = s.labels.get(name);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    function reference(scope, node, isWrite = false) {
+        const symbol = lookupBinding(scope, node.name);
+        if (symbol) {
+            symbol.references.push(node);
+            identifierSymbols.set(node, symbol);
+            return;
+        }
+        let binding = globals.get(node.name);
+        if (!binding) {
+            binding = { name: node.name, references: [], writes: [] };
+            globals.set(node.name, binding);
+        }
+        binding.references.push(node);
+        if (isWrite) {
+            binding.writes.push(node);
+        }
+        globalReferenceNodes.add(node);
+    }
+    // ラベルはブロック内での宣言位置に関わらずブロック全体から参照できる
+    // （前方goto）ため、通常の宣言文と違い先読みで登録する。
+    function hoistLabels(body, scope) {
+        body.forEach((statement) => {
+            if (statement.type === "LabelStatement") {
+                declareLabel(scope, statement.label);
+            }
+        });
+    }
+    function resolveBlock(body, scope) {
+        hoistLabels(body, scope);
+        body.forEach((statement) => {
+            resolveStatement(statement, scope);
+        });
+    }
+    function resolveStatement(statement, scope) {
+        switch (statement.type) {
+            case "LocalStatement":
+                // 初期化式は新しいローカルが宣言される前の束縛で解決する
+                // （`local x = x` の右辺は外側のxを指す）
+                statement.init.forEach((expr) => {
+                    resolveExpression(expr, scope);
+                });
+                statement.variables.forEach((v) => declare(scope, v, "local"));
+                return;
+            case "AssignmentStatement":
+                statement.init.forEach((expr) => {
+                    resolveExpression(expr, scope);
+                });
+                statement.variables.forEach((v) => {
+                    if (v.type === "Identifier") {
+                        reference(scope, v, true);
+                    }
+                    else {
+                        resolveExpression(v, scope);
+                    }
+                });
+                return;
+            case "CallStatement":
+                resolveExpression(statement.expression, scope);
+                return;
+            case "DoStatement": {
+                const inner = createScope("block", scope);
+                resolveBlock(statement.body, inner);
+                return;
+            }
+            case "WhileStatement": {
+                resolveExpression(statement.condition, scope);
+                const inner = createScope("block", scope);
+                resolveBlock(statement.body, inner);
+                return;
+            }
+            case "RepeatStatement": {
+                // `until`の条件式は本体で宣言されたローカルを参照できる
+                const inner = createScope("block", scope);
+                resolveBlock(statement.body, inner);
+                resolveExpression(statement.condition, inner);
+                return;
+            }
+            case "IfStatement":
+                statement.clauses.forEach((clause) => {
+                    if (clause.type !== "ElseClause") {
+                        resolveExpression(clause.condition, scope);
+                    }
+                    const inner = createScope("block", scope);
+                    resolveBlock(clause.body, inner);
+                });
+                return;
+            case "ForNumericStatement": {
+                resolveExpression(statement.start, scope);
+                resolveExpression(statement.end, scope);
+                if (statement.step) {
+                    resolveExpression(statement.step, scope);
+                }
+                const inner = createScope("block", scope);
+                declare(inner, statement.variable, "for");
+                resolveBlock(statement.body, inner);
+                return;
+            }
+            case "ForGenericStatement": {
+                statement.iterators.forEach((iterator) => {
+                    resolveExpression(iterator, scope);
+                });
+                const inner = createScope("block", scope);
+                statement.variables.forEach((v) => declare(inner, v, "for"));
+                resolveBlock(statement.body, inner);
+                return;
+            }
+            case "FunctionDeclaration":
+                resolveFunctionDeclaration(statement, scope);
+                return;
+            case "ReturnStatement":
+                statement.arguments.forEach((argument) => {
+                    resolveExpression(argument, scope);
+                });
+                return;
+            case "BreakStatement":
+                return;
+            case "LabelStatement":
+                // hoistLabelsで宣言済みのため、ここでは何もしない
+                return;
+            case "GotoStatement": {
+                const symbol = lookupLabel(scope, statement.label.name);
+                if (symbol) {
+                    symbol.references.push(statement.label);
+                    identifierSymbols.set(statement.label, symbol);
+                }
+                return;
+            }
+            default: {
+                const exhaustive = statement;
+                throw new TypeError("Unknown statement type: `" + JSON.stringify(exhaustive) + "`");
+            }
+        }
+    }
+    function resolveFunctionDeclaration(fn, scope) {
+        if (fn.identifier) {
+            if (fn.identifier.type === "Identifier") {
+                if (fn.isLocal) {
+                    // `local function`は再帰呼び出しのため、本体を解決する前に自身を宣言する
+                    declare(scope, fn.identifier, "local");
+                }
+                else {
+                    // 非local: 既存のローカル/グローバルへの代入として扱う（新規宣言ではない）
+                    reference(scope, fn.identifier, true);
+                }
+            }
+            else {
+                resolveExpression(fn.identifier, scope);
+            }
+        }
+        const inner = createScope("function", scope);
+        fn.parameters.forEach((parameter) => {
+            if (parameter.type === "Identifier") {
+                declare(inner, parameter, "param");
+            }
+        });
+        resolveBlock(fn.body, inner);
+    }
+    function resolveExpression(expr, scope) {
+        switch (expr.type) {
+            case "Identifier":
+                reference(scope, expr);
+                return;
+            case "StringLiteral":
+            case "NumericLiteral":
+            case "BooleanLiteral":
+            case "NilLiteral":
+            case "VarargLiteral":
+                return;
+            case "LogicalExpression":
+            case "BinaryExpression":
+                resolveExpression(expr.left, scope);
+                resolveExpression(expr.right, scope);
+                return;
+            case "UnaryExpression":
+                resolveExpression(expr.argument, scope);
+                return;
+            case "CallExpression":
+                resolveExpression(expr.base, scope);
+                expr.arguments.forEach((argument) => {
+                    resolveExpression(argument, scope);
+                });
+                return;
+            case "TableCallExpression":
+                resolveExpression(expr.base, scope);
+                resolveExpression(expr.arguments, scope);
+                return;
+            case "StringCallExpression":
+                resolveExpression(expr.base, scope);
+                resolveExpression(expr.argument, scope);
+                return;
+            case "IndexExpression":
+                resolveExpression(expr.base, scope);
+                resolveExpression(expr.index, scope);
+                return;
+            case "MemberExpression":
+                resolveExpression(expr.base, scope);
+                // フィールド名（`.identifier`）は変数参照ではないため解決しない
+                return;
+            case "FunctionDeclaration": {
+                const inner = createScope("function", scope);
+                expr.parameters.forEach((parameter) => {
+                    if (parameter.type === "Identifier") {
+                        declare(inner, parameter, "param");
+                    }
+                });
+                resolveBlock(expr.body, inner);
+                return;
+            }
+            case "TableConstructorExpression":
+                expr.fields.forEach((field) => {
+                    if (field.type === "TableKey") {
+                        resolveExpression(field.key, scope);
+                        resolveExpression(field.value, scope);
+                    }
+                    else if (field.type === "TableValue") {
+                        resolveExpression(field.value, scope);
+                    }
+                    else {
+                        // TableKeyString: キー名（`{ key = value }`のkey）は変数参照ではない
+                        resolveExpression(field.value, scope);
+                    }
+                });
+                return;
+            default: {
+                const exhaustive = expr;
+                throw new TypeError("Unknown expression type: `" + JSON.stringify(exhaustive) + "`");
+            }
+        }
+    }
+    const chunkScope = createScope("chunk", null);
+    resolveBlock(chunk.body, chunkScope);
+    return {
+        chunkScope,
+        symbols: allSymbols,
+        globals,
+        symbolOf: (identifier) => identifierSymbols.get(identifier),
+        isGlobalReference: (identifier) => globalReferenceNodes.has(identifier),
+    };
+}