storm-lua-minify 0.2.0 → 0.3.0

package/dist/resolver.js

@@ -6,6 +6,7 @@ function resolveScopes(chunk) {
     const allSymbols = [];
     const globals = new Map();
     const identifierSymbols = new WeakMap();
+    const globalReferenceNodes = new WeakSet();
     function createScope(kind, parent) {
         const scope = {
             kind,
@@ -67,7 +68,7 @@ function resolveScopes(chunk) {
         }
         return undefined;
     }
-    function reference(scope, node) {
+    function reference(scope, node, isWrite = false) {
         const symbol = lookupBinding(scope, node.name);
         if (symbol) {
             symbol.references.push(node);
@@ -76,10 +77,14 @@ function resolveScopes(chunk) {
         }
         let binding = globals.get(node.name);
         if (!binding) {
-            binding = { name: node.name, references: [] };
+            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）ため、通常の宣言文と違い先読みで登録する。
@@ -112,7 +117,7 @@ function resolveScopes(chunk) {
                 });
                 statement.variables.forEach((v) => {
                     if (v.type === "Identifier") {
-                        reference(scope, v);
+                        reference(scope, v, true);
                     }
                     else {
                         resolveExpression(v, scope);
@@ -205,7 +210,7 @@ function resolveScopes(chunk) {
                 }
                 else {
                     // 非local: 既存のローカル/グローバルへの代入として扱う（新規宣言ではない）
-                    reference(scope, fn.identifier);
+                    reference(scope, fn.identifier, true);
                 }
             }
             else {
@@ -299,5 +304,6 @@ function resolveScopes(chunk) {
         symbols: allSymbols,
         globals,
         symbolOf: (identifier) => identifierSymbols.get(identifier),
+        isGlobalReference: (identifier) => globalReferenceNodes.has(identifier),
     };
 }

package/dist/transform.js

@@ -0,0 +1,401 @@
+"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;
+}
+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)) {
+            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;
+        });
+        newLocals.push({
+            type: "LocalStatement",
+            variables: [{ type: "Identifier", name: tempName }],
+            init: [{ type: "Identifier", name: binding.name }],
+        });
+    });
+    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);
+}

package/package.json

@@ -1,33 +1,41 @@
-{
-  "name": "storm-lua-minify",
-  "description": "A Lua minifier also outputs source map",
-  "version": "0.2.0",
-  "dependencies": {
-    "commander": "^12.1.0",
-    "luaparse": "^0.3.1",
-    "source-map": "^0.7.4"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.39.5",
-    "@types/node": "^22.20.1",
-    "@types/luaparse": "^0.2.13",
-    "eslint": "^9.39.5",
-    "eslint-config-prettier": "^10.1.8",
-    "globals": "^17.7.0",
-    "prettier": "^3.9.5",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.63.0"
-  },
-  "bin": "dist/cli.js",
-  "scripts": {
-    "start": "node ./dist/index.js",
-    "build": "npx tsc",
-    "test": "node -r ts-node/register/transpile-only --test \"test/**/*.test.ts\"",
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
-  },
-  "author": "Nona Takahara <nona_t_2612@yahoo.co.jp>",
-  "license": "MIT"
-}
+{
+  "name": "storm-lua-minify",
+  "description": "A Lua minifier also outputs source map",
+  "version": "0.3.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^12.1.0",
+    "luaparse": "^0.3.1",
+    "source-map": "^0.7.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.5",
+    "@types/luaparse": "^0.2.13",
+    "@types/node": "^22.20.1",
+    "eslint": "^9.39.5",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.7.0",
+    "prettier": "^3.9.5",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.63.0",
+    "vitest": "^4.1.10"
+  },
+  "author": "Nona Takahara <nona_t_2612@yahoo.co.jp>",
+  "license": "MIT",
+  "scripts": {
+    "start": "node ./dist/cli.js",
+    "build": "tsc",
+    "test": "tsc -p tsconfig.eslint.json && npx vitest run",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  "bin": {
+    "storm-lua-minify": "dist/cli.js"
+  }
+}

package/.github/workflows/ci.yml

@@ -1,39 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-      - main
-      - develop
-  pull_request:
-    branches:
-      - main
-      - develop
-
-jobs:
-  build-lint-test:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22.x"
-          cache: "npm"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build
-        run: npm run build
-
-      - name: Lint
-        run: npm run lint
-
-      - name: Check formatting
-        run: npm run format:check
-
-      - name: Test
-        run: npm test

package/.github/workflows/publish.yml

@@ -1,39 +0,0 @@
-name: Publish to npm
-
-# NOTE: npm publish is disabled for now (see issue #10).
-# Once the repository is ready to publish (NPM_TOKEN secret configured,
-# owner sign-off), uncomment the "Publish" step below.
-on:
-  release:
-    types: [published]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22.x"
-          cache: "npm"
-          registry-url: "https://registry.npmjs.org"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build
-        run: npm run build
-
-      - name: Lint
-        run: npm run lint
-
-      - name: Test
-        run: npm test
-
-      # - name: Publish
-      #   run: npm publish
-      #   env:
-      #     NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.prettierignore

@@ -1,3 +0,0 @@
-dist
-node_modules
-package-lock.json

package/.prettierrc.json

@@ -1 +0,0 @@
-{}

package/eslint.config.js

@@ -1,29 +0,0 @@
-// @ts-check
-const eslint = require("@eslint/js");
-const tseslint = require("typescript-eslint");
-const globals = require("globals");
-const eslintConfigPrettier = require("eslint-config-prettier");
-
-module.exports = tseslint.config(
-  {
-    ignores: ["dist/**"],
-  },
-  {
-    files: ["src/**/*.ts", "test/**/*.ts"],
-    extends: [
-      eslint.configs.recommended,
-      ...tseslint.configs.strictTypeChecked,
-      ...tseslint.configs.stylistic,
-    ],
-    languageOptions: {
-      globals: {
-        ...globals.node,
-      },
-      parserOptions: {
-        project: "./tsconfig.eslint.json",
-        tsconfigRootDir: __dirname,
-      },
-    },
-  },
-  eslintConfigPrettier,
-);