storm-lua-minify 0.1.3 → 0.2.0

package/dist/linker.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticStringArgument = staticStringArgument;
+exports.findModuleReferences = findModuleReferences;
+/**
+ * Chunk配下を型を問わず再帰的に走査するジェネリックウォーカー。
+ * printerとは独立に、AST全体からrequire/dofile呼び出しを見つけ出すために使う（#18）。
+ */
+function walk(node, visit) {
+    if (node === null || typeof node !== "object") {
+        return;
+    }
+    if (Array.isArray(node)) {
+        node.forEach((child) => {
+            walk(child, visit);
+        });
+        return;
+    }
+    const obj = node;
+    if (typeof obj.type === "string") {
+        visit(obj);
+    }
+    for (const key of Object.keys(obj)) {
+        if (key === "loc" || key === "range") {
+            continue;
+        }
+        walk(obj[key], visit);
+    }
+}
+// luaparseはデフォルト設定（encodingMode: "none"）ではStringLiteral.valueを
+// 常にnullにする（discardStrings）ため、rawから引用符を取り除いて文字列値を得る。
+// require/dofileのモジュール名として使う簡単な文字列リテラルのみを想定しており、
+// エスケープシーケンスの解釈までは行わない。
+function unquoteRaw(raw) {
+    if (raw.length >= 2) {
+        const first = raw.charAt(0);
+        const last = raw.charAt(raw.length - 1);
+        if ((first === '"' || first === "'") && first === last) {
+            return raw.slice(1, -1);
+        }
+    }
+    return raw;
+}
+function staticStringArgument(node) {
+    if (node !== null &&
+        typeof node === "object" &&
+        node.type === "StringLiteral" &&
+        typeof node.raw === "string") {
+        return unquoteRaw(node.raw);
+    }
+    return undefined;
+}
+function calleeName(node) {
+    if (node !== null &&
+        typeof node === "object" &&
+        node.type === "Identifier" &&
+        typeof node.name === "string") {
+        return node.name;
+    }
+    return undefined;
+}
+/**
+ * ASTを走査してrequire/dofile呼び出し（CallExpression / StringCallExpression の両構文）を
+ * 静的な文字列引数付きのものに限って列挙する。同一モジュールへの参照は重複したまま返す
+ * （呼び出し側で重複排除する）。
+ */
+function findModuleReferences(ast) {
+    const refs = [];
+    walk(ast, (node) => {
+        if (node.type === "CallExpression") {
+            const name = calleeName(node.base);
+            if (name !== "require" && name !== "dofile") {
+                return;
+            }
+            const args = node.arguments;
+            if (!Array.isArray(args) || args.length === 0) {
+                return;
+            }
+            const moduleName = staticStringArgument(args[0]);
+            if (moduleName !== undefined) {
+                refs.push({ kind: name, moduleName });
+            }
+        }
+        else if (node.type === "StringCallExpression") {
+            const name = calleeName(node.base);
+            if (name !== "require" && name !== "dofile") {
+                return;
+            }
+            const moduleName = staticStringArgument(node.argument);
+            if (moduleName !== undefined) {
+                refs.push({ kind: name, moduleName });
+            }
+        }
+    });
+    return refs;
+}

package/dist/minifier.js

@@ -9,22 +9,31 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const source_map_1 = require("source-map");
 const ast2lua_1 = require("./ast2lua");
+const linker_1 = require("./linker");
+const resolver_1 = require("./resolver");
+const renamer_1 = require("./renamer");
+const NO_RENAME = {
+    nameOf: () => undefined,
+    usedNames: new Set(),
+};
 class Minifier {
-    identifierMap;
     identifiersInUse;
     moduleSourceText;
-    moduleSourceNode;
     moduleAST;
     moduleNameAndFileName;
     dir;
     entryModule;
     mode;
     luaParseSettings;
+    // Linkパスで解決されたモジュール名を、依存されている側が先に来る順序で並べたもの
+    linkOrder = [];
+    // モジュールごとのResolveパスの結果（Linkパスで一度だけ計算し使い回す）
+    moduleResolve = new Map();
+    // モジュールごとのRenameパスの結果（初回アクセス時に計算しキャッシュする）
+    renameCache = new Map();
     constructor(entryFilePath, luaParseSettings, mode) {
-        this.identifierMap = new Map();
         this.identifiersInUse = new Set();
         this.moduleSourceText = new Map();
-        this.moduleSourceNode = new Map();
         this.moduleAST = new Map();
         this.moduleNameAndFileName = new Map();
         this.luaParseSettings = luaParseSettings;
@@ -34,65 +43,177 @@ class Minifier {
         this.entryModule = pn.name;
     }
     parse() {
-        const sn = this.parseModule(this.entryModule);
-        if (this.mode.moduleLikeLua) {
-            // require関数を作成し、流し込む
-            /*
-            function require(m,r)
-              package=package or {loaded={}}
-              if package.loaded[m] then return package.loaded[m] end
-              if m=="<MODULE_NAME>" then r=(function()[[MODULE]]end)() end
-              package.loaded[m]=package.loaded[m] or r or true;return package.loaded[m]
-            end
-            */
-            sn.prepend("package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end\n");
-            this.moduleSourceNode.forEach((v, k) => {
-                if (k !== this.entryModule) {
-                    sn.prepend(["if m==\"", k, "\"then r=(function() ", v, " end)()end\n"]);
-                }
-            });
-            sn.prepend("function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end\n");
-        }
-        // コメントの流し込み
-        const comments = this.moduleAST.get(this.entryModule)?.comments;
-        if (comments) {
-            comments
-                .reverse()
+        this.link();
+        this.renameAll();
+        const parts = [];
+        const entryComments = this.moduleAST.get(this.entryModule)?.comments;
+        if (entryComments) {
+            entryComments
                 .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
                 .forEach((comment) => {
-                sn.prepend([
-                    new source_map_1.SourceNode(comment.loc?.start.line || null, comment.loc?.start.column || null, this.entryModule, // 本当に自分のファイル名でよいかは要検討
-                    comment.raw),
-                    "\n"
-                ]);
+                parts.push(new source_map_1.SourceNode(comment.loc?.start.line ?? null, comment.loc?.start.column ?? null, this.moduleNameAndFileName.get(this.entryModule) ?? null, comment.raw), "\n");
             });
         }
-        this.moduleSourceText.forEach((v, k) => { const fileName = this.moduleNameAndFileName.get(k); fileName && sn.setSourceContent(fileName, v); });
-        return sn;
+        if (this.mode.moduleLikeLua) {
+            parts.push(this.buildRequireWrapper());
+        }
+        parts.push(this.printModule(this.entryModule));
+        const result = new source_map_1.SourceNode(null, null, null, parts);
+        this.moduleSourceText.forEach((v, k) => {
+            const fileName = this.moduleNameAndFileName.get(k);
+            if (fileName) {
+                result.setSourceContent(fileName, v);
+            }
+        });
+        return result;
+    }
+    /**
+     * dofileの呼び出し箇所ごとに、キャッシュ済みASTから新規にSourceNodeを作り直す。
+     * 同じSourceNodeインスタンスを複数箇所へ挿入すると壊れるため、常に作り直す（#18）。
+     */
+    printModuleInline(moduleName) {
+        return this.printModule(moduleName);
+    }
+    /**
+     * requireを式（IIFE）ではなく文として展開できる場合に使う。モジュール本体が
+     * 「単一の式を返すreturn文」で終わっている場合のみ結果を返す。それ以外は
+     * undefinedを返すので、呼び出し側は従来のIIFE方式にフォールバックする（#29）。
+     */
+    splitModuleForStatementSplice(moduleName) {
+        const ast = this.moduleAST.get(moduleName);
+        const fileName = this.moduleNameAndFileName.get(moduleName);
+        if (!ast || !fileName) {
+            throw new Error(moduleName + " is not found");
+        }
+        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parseAsStatementsAndFinalExpression(moduleName === this.entryModule);
+    }
+    /**
+     * 指定モジュールのRenameパス結果を返す。`renameAll`で事前に計算済みの
+     * ものをそのまま返すだけの参照用アクセサ。
+     */
+    getRenameResult(moduleName) {
+        if (this.mode.rename === false) {
+            return NO_RENAME;
+        }
+        const cached = this.renameCache.get(moduleName);
+        if (!cached) {
+            throw new Error(moduleName + " is not found");
+        }
+        return cached;
     }
-    parseModule(moduleName) {
-        const resolvePath = moduleName.replaceAll(".", path_1.default.sep) + ".lua";
-        const fullResolvePath = path_1.default.join(this.dir, resolvePath);
-        if (this.moduleSourceNode.has(moduleName)) {
-            const res = this.moduleSourceNode.get(moduleName);
-            if (res) {
-                return res;
+    /**
+     * Renameパス（#20）: linkOrder（依存されている側が先）の順にモジュールごとの
+     * 短縮名を割り当てる。
+     *
+     * dofileやSLモードのrequireその場展開は、呼び出し元と同じLuaスコープに
+     * 関数で包まずに直接展開されるため、モジュールをまたいで同じ短縮名を
+     * 再利用すると本来無関係な変数同士が衝突しうる（#12）。これを安全に防ぐため、
+     * あるモジュールが実際に使った短縮名は、後続モジュールを処理する前に
+     * `identifiersInUse`（予約名の集合）へ積み増す。これにより短縮名は
+     * プログラム全体で重複しなくなる（モジュール間での再利用による圧縮は
+     * 犠牲になるが、モジュール内でのスコープに基づく再利用は維持される）。
+     */
+    renameAll() {
+        if (this.mode.rename === false) {
+            return;
+        }
+        this.linkOrder.forEach((moduleName) => {
+            const resolved = this.moduleResolve.get(moduleName);
+            if (!resolved) {
+                throw new Error(moduleName + " is not found");
             }
+            const result = (0, renamer_1.assignRenames)(resolved, this.identifiersInUse);
+            this.renameCache.set(moduleName, result);
+            result.usedNames.forEach((name) => this.identifiersInUse.add(name));
+        });
+    }
+    printModule(moduleName) {
+        const ast = this.moduleAST.get(moduleName);
+        const fileName = this.moduleNameAndFileName.get(moduleName);
+        if (!ast || !fileName) {
+            throw new Error(moduleName + " is not found");
         }
-        else if (fs_1.default.existsSync(fullResolvePath)) {
+        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parse(moduleName === this.entryModule);
+    }
+    /**
+     * エントリファイルから到達可能な全モジュールをASTレベルで解決するLinkパス（#18）。
+     * - ファイルごとのパースは一度だけ行う（同一モジュールの多重require/dofileの重複排除）
+     * - require/dofileの参照グラフに循環があればエラーを投げる
+     * - 出力（Print）を開始する前に、必要なモジュール解決をすべて完了させる
+     */
+    link() {
+        const visiting = new Set();
+        const stack = [];
+        const visit = (moduleName) => {
+            if (visiting.has(moduleName)) {
+                const cycleStart = stack.indexOf(moduleName);
+                const cycle = [...stack.slice(cycleStart), moduleName];
+                throw new Error("Circular require/dofile detected: " + cycle.join(" -> "));
+            }
+            if (this.moduleAST.has(moduleName)) {
+                // 解決済み（このモジュールは複数箇所から参照されていても一度しかパースしない）
+                return;
+            }
+            visiting.add(moduleName);
+            stack.push(moduleName);
+            const fullResolvePath = path_1.default.join(this.dir, ...moduleName.split(".")) + ".lua";
+            if (!fs_1.default.existsSync(fullResolvePath)) {
+                throw new Error(moduleName + " is not found");
+            }
             const code = fs_1.default.readFileSync(fullResolvePath).toString();
             const ast = luaparse_1.default.parse(code, this.luaParseSettings);
-            if ("globals" in ast) {
-                ast.globals?.map((v) => this.identifiersInUse.add(v.name));
-                const sourceNode = new ast2lua_1.MinifyFile(resolvePath, ast, this, this.mode).parse(moduleName === this.entryModule);
-                this.moduleSourceText.set(moduleName, code);
-                this.moduleAST.set(moduleName, ast);
-                this.moduleSourceNode.set(moduleName, sourceNode);
-                this.moduleNameAndFileName.set(moduleName, resolvePath);
-                return sourceNode;
+            // Resolveパス（#19）: このモジュールのスコープ/シンボルを解析し、Renameパスの
+            // 入力として使い回せるようキャッシュする。グローバル参照はプログラム全体で
+            // 予約すべき名前（identifiersInUse）としてここで集計する。
+            const resolved = (0, resolver_1.resolveScopes)(ast);
+            this.moduleResolve.set(moduleName, resolved);
+            resolved.globals.forEach((binding) => this.identifiersInUse.add(binding.name));
+            this.moduleSourceText.set(moduleName, code);
+            this.moduleAST.set(moduleName, ast);
+            // Source Mapの`sources`はURLとして解釈されるため、OS依存のpath.sepではなく
+            // 常に"/"区切りで保持する（Windows上でのビルドでも壊れないように）。
+            this.moduleNameAndFileName.set(moduleName, moduleName.replaceAll(".", "/") + ".lua");
+            (0, linker_1.findModuleReferences)(ast).forEach((ref) => {
+                visit(ref.moduleName);
+            });
+            visiting.delete(moduleName);
+            stack.pop();
+            this.linkOrder.push(moduleName);
+        };
+        visit(this.entryModule);
+    }
+    /**
+     * require()（dofileは除く）で参照されているモジュール名の集合を求める。
+     * dofileは呼び出しごとに毎回展開しなおすため、キャッシュ／ホイストの対象にしない。
+     */
+    collectRequireTargets() {
+        const targets = new Set();
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            if (!ast) {
+                return;
             }
-        }
-        throw new Error(moduleName + " is not found");
+            (0, linker_1.findModuleReferences)(ast).forEach((ref) => {
+                if (ref.kind === "require") {
+                    targets.add(ref.moduleName);
+                }
+            });
+        });
+        return targets;
+    }
+    buildRequireWrapper() {
+        const targets = this.collectRequireTargets();
+        const parts = [
+            "function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end\n",
+        ];
+        this.linkOrder.forEach((moduleName) => {
+            if (moduleName === this.entryModule || !targets.has(moduleName)) {
+                return;
+            }
+            parts.push('if m=="', moduleName, '"then r=(function() ', this.printModule(moduleName), " end)()end\n");
+        });
+        parts.push("package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end\n");
+        return new source_map_1.SourceNode(null, null, null, parts);
     }
 }
 exports.Minifier = Minifier;

package/dist/output.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMinifiedOutput = buildMinifiedOutput;
+const path_1 = __importDefault(require("path"));
+/**
+ * ミニファイ済みSourceNodeに、sourceMappingURLアノテーションとSource Mapを
+ * 付加した最終的な出力を組み立てる。アノテーションの出力形式は
+ * `BuildMinifiedOutputOptions.sourceMappingUrlStyle`で選択する。
+ */
+function buildMinifiedOutput(sourceNode, minFileName, mapFileName, options = {}) {
+    const style = options.sourceMappingUrlStyle ?? "legacy";
+    const marker = "//# sourceMappingURL=" + path_1.default.basename(mapFileName);
+    if (style === "legacy") {
+        // 旧storm-lua-minifyと完全に同じ出力（末尾に改行は付加しない）。
+        sourceNode.add("\n--[[\n" + marker + "\n]]");
+    }
+    else if (style === "line") {
+        sourceNode.add("\n-- " + marker + "\n");
+    }
+    else {
+        sourceNode.add("\n" + marker + "\n");
+    }
+    const sourceAndMap = sourceNode.toStringWithSourceMap({
+        file: path_1.default.basename(minFileName),
+    });
+    return {
+        code: sourceAndMap.code,
+        map: JSON.stringify(sourceAndMap.map),
+    };
+}

package/dist/renamer.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+    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);
+            return symbol ? nameOfSymbol.get(symbol) : undefined;
+        },
+        usedNames: new Set(nameOfSlot.values()),
+    };
+}