storm-lua-minify 0.1.2 → 0.2.0

package/test/fixtures/entry-scope-many-requires/dep_kilo.lua

@@ -0,0 +1,2 @@
+local valueKilo = "dep_kilo"
+return { id = valueKilo }

package/test/fixtures/entry-scope-many-requires/main.lua

@@ -0,0 +1,25 @@
+local depAlpha = require("dep_alpha")
+local depBravo = require("dep_bravo")
+local depCharlie = require("dep_charlie")
+local depDelta = require("dep_delta")
+local depEcho = require("dep_echo")
+local depFoxtrot = require("dep_foxtrot")
+local depGolf = require("dep_golf")
+local depHotel = require("dep_hotel")
+local depIndia = require("dep_india")
+local depJuliet = require("dep_juliet")
+local depKilo = require("dep_kilo")
+
+print(
+  depAlpha,
+  depBravo,
+  depCharlie,
+  depDelta,
+  depEcho,
+  depFoxtrot,
+  depGolf,
+  depHotel,
+  depIndia,
+  depJuliet,
+  depKilo
+)

package/test/fixtures/multi-require/common.lua

@@ -0,0 +1 @@
+return { value = 42 }

package/test/fixtures/multi-require/main.lua

@@ -0,0 +1,3 @@
+local a = require("common")
+local b = require("common")
+print(a.value, b.value)

package/test/fixtures/nested-module/main.lua

@@ -0,0 +1,2 @@
+local deep = require("sub.deep")
+print(deep.value)

package/test/fixtures/nested-module/sub/deep.lua

@@ -0,0 +1 @@
+return { value = 1 }

package/test/fixtures/require-call/main.lua

@@ -0,0 +1,2 @@
+local greeter = require("mod")
+print(greeter.hello())

package/test/fixtures/require-call/mod.lua

@@ -0,0 +1,5 @@
+local function hello()
+  return "hello"
+end
+
+return { hello = hello }

package/test/fixtures/require-in-expression/main.lua

@@ -0,0 +1 @@
+print(require("mod").hello())

package/test/fixtures/require-in-expression/mod.lua

@@ -0,0 +1 @@
+return { hello = function() return "hello" end }

package/test/fixtures/require-string-call/main.lua

@@ -0,0 +1,2 @@
+local greeter = require "mod"
+print(greeter.hello())

package/test/fixtures/require-string-call/mod.lua

@@ -0,0 +1,5 @@
+local function hello()
+  return "hello"
+end
+
+return { hello = hello }

package/test/fixtures/single-file/main.lua

@@ -0,0 +1,15 @@
+local function add(first, second)
+  return first + second
+end
+
+local total = 0
+for index = 1, 10 do
+  total = add(total, index)
+end
+
+local i = 0
+while i < 3 do
+  i = i + 1
+end
+
+print(total, i)

package/test/identifier-collision.test.ts

@@ -0,0 +1,28 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { WORKING_CASES, KNOWN_BUG_CASES, runMinifier } from "./lib/helpers";
+import { findIdentifierCollisions } from "./lib/collision";
+
+// 出力コードの同一スコープ内で、同じ短縮識別子が異なるオリジナル識別子に
+// 割り当てられていないことを検証する（#12の回帰防止）。
+
+for (const c of WORKING_CASES) {
+  void test(`identifier collision: ${c.label}`, async () => {
+    const { code, map } = runMinifier(c);
+    const collisions = await findIdentifierCollisions(code, map);
+    assert.deepEqual(collisions, []);
+  });
+}
+
+for (const c of KNOWN_BUG_CASES) {
+  const issue = String(c.issue);
+  void test(
+    `identifier collision (known bug, issue #${issue}): ${c.label}`,
+    { todo: `#${issue} の本修正待ち` },
+    async () => {
+      const { code, map } = runMinifier(c);
+      const collisions = await findIdentifierCollisions(code, map);
+      assert.deepEqual(collisions, []);
+    },
+  );
+}

package/test/lib/collision.ts

@@ -0,0 +1,131 @@
+import Parser from "luaparse";
+import { RawSourceMap, SourceMapConsumer } from "source-map";
+
+export interface IdentifierCollision {
+  scope: string;
+  shortName: string;
+  originalNames: string[];
+}
+
+interface Declaration {
+  name: string;
+  original: string | null;
+}
+
+// 出力（minify後）のLuaコードを対象に、同一スコープ内で同じ短縮名が
+// 「別のオリジナル識別子」に割り当てられていないかを検証する（#12の回帰防止）。
+//
+// 既知の制限（テストハーネスの簡易実装）:
+// - 文（Statement）としてのスコープのみを辿る。式中の無名関数
+//   （例: `local t = { f = function() ... end }`）の内部は対象外。
+export async function findIdentifierCollisions(
+  code: string,
+  rawMap: RawSourceMap,
+): Promise<IdentifierCollision[]> {
+  const ast = Parser.parse(code, { luaVersion: "5.3", locations: true });
+  const collisions: IdentifierCollision[] = [];
+
+  await SourceMapConsumer.with(rawMap, null, (consumer) => {
+    const originalNameFor = (node: {
+      loc?: Parser.Node["loc"];
+    }): string | null => {
+      if (!node.loc) {
+        return null;
+      }
+      const pos = consumer.originalPositionFor({
+        line: node.loc.start.line,
+        column: node.loc.start.column,
+      });
+      return pos.name;
+    };
+
+    const checkScope = (scopeName: string, declarations: Declaration[]) => {
+      const byShortName = new Map<string, Set<string>>();
+      for (const decl of declarations) {
+        if (decl.original === null) {
+          continue;
+        }
+        if (!byShortName.has(decl.name)) {
+          byShortName.set(decl.name, new Set());
+        }
+        byShortName.get(decl.name)?.add(decl.original);
+      }
+      for (const [shortName, originalNames] of byShortName) {
+        if (originalNames.size > 1) {
+          collisions.push({
+            scope: scopeName,
+            shortName,
+            originalNames: [...originalNames],
+          });
+        }
+      }
+    };
+
+    let scopeCounter = 0;
+
+    const walkBlock = (scopeLabel: string, body: Parser.Statement[]) => {
+      const declarations: Declaration[] = [];
+      for (const statement of body) {
+        collectFromStatement(statement, declarations);
+      }
+      checkScope(scopeLabel, declarations);
+    };
+
+    const collectFromStatement = (
+      statement: Parser.Statement,
+      declarations: Declaration[],
+    ) => {
+      switch (statement.type) {
+        case "LocalStatement":
+          for (const v of statement.variables) {
+            declarations.push({ name: v.name, original: originalNameFor(v) });
+          }
+          break;
+        case "ForNumericStatement":
+          declarations.push({
+            name: statement.variable.name,
+            original: originalNameFor(statement.variable),
+          });
+          walkBlock(`for#${String(scopeCounter++)}`, statement.body);
+          break;
+        case "ForGenericStatement":
+          for (const v of statement.variables) {
+            declarations.push({ name: v.name, original: originalNameFor(v) });
+          }
+          walkBlock(`for#${String(scopeCounter++)}`, statement.body);
+          break;
+        case "FunctionDeclaration": {
+          const paramDeclarations: Declaration[] = statement.parameters
+            .filter((p): p is Parser.Identifier => p.type === "Identifier")
+            .map((p) => ({ name: p.name, original: originalNameFor(p) }));
+          const bodyDeclarations = [...paramDeclarations];
+          for (const inner of statement.body) {
+            collectFromStatement(inner, bodyDeclarations);
+          }
+          checkScope(`function#${String(scopeCounter++)}`, bodyDeclarations);
+          break;
+        }
+        case "DoStatement":
+          walkBlock(`do#${String(scopeCounter++)}`, statement.body);
+          break;
+        case "WhileStatement":
+          walkBlock(`while#${String(scopeCounter++)}`, statement.body);
+          break;
+        case "RepeatStatement":
+          walkBlock(`repeat#${String(scopeCounter++)}`, statement.body);
+          break;
+        case "IfStatement":
+          for (const clause of statement.clauses) {
+            walkBlock(`if#${String(scopeCounter++)}`, clause.body);
+          }
+          break;
+        default:
+          break;
+      }
+    };
+
+    walkBlock("chunk", ast.body);
+  });
+
+  return collisions;
+}

package/test/lib/helpers.ts

@@ -0,0 +1,124 @@
+import path from "path";
+import { Options } from "luaparse";
+import { RawSourceMap } from "source-map";
+import { Minifier, MinifierMode } from "../../src/minifier";
+
+export const FIXTURES_DIR = path.join(__dirname, "..", "fixtures");
+export const SNAPSHOTS_DIR = path.join(__dirname, "..", "snapshots");
+
+export const LUAPARSE_SETTINGS: Partial<Options> = {
+  locations: true,
+  luaVersion: "5.3",
+  ranges: true,
+  scope: true,
+};
+
+export interface FixtureCase {
+  label: string;
+  fixture: string;
+  entry?: string;
+  mode: MinifierMode;
+}
+
+export interface KnownBugCase extends FixtureCase {
+  issue: number;
+}
+
+export function fixtureEntryPath(fixture: string, entry = "main.lua"): string {
+  return path.join(FIXTURES_DIR, fixture, entry);
+}
+
+export function slug(c: Pick<FixtureCase, "fixture" | "mode">): string {
+  return `${c.fixture}.${c.mode.moduleLikeLua ? "m" : "sl"}`;
+}
+
+export function runMinifier(c: FixtureCase): {
+  code: string;
+  map: RawSourceMap;
+} {
+  const minifier = new Minifier(
+    fixtureEntryPath(c.fixture, c.entry),
+    LUAPARSE_SETTINGS,
+    c.mode,
+  );
+  const sourceNode = minifier.parse();
+  const { code, map } = sourceNode.toStringWithSourceMap({
+    file: c.fixture + ".min.lua",
+  });
+  return { code, map: map.toJSON() };
+}
+
+// require() / require "m" / dofile が正しく解決される、動作が確認できているケース。
+// スナップショット・ラウンドトリップ・識別子衝突検知の全テストで「衝突・構文エラーが無い」ことを期待する。
+export const WORKING_CASES: FixtureCase[] = [
+  {
+    label: "単一ファイル",
+    fixture: "single-file",
+    mode: { moduleLikeLua: false },
+  },
+  {
+    label: 'require("m") 構文 (-m モード)',
+    fixture: "require-call",
+    mode: { moduleLikeLua: true },
+  },
+  {
+    label: "dofile (SLモード)",
+    fixture: "dofile",
+    mode: { moduleLikeLua: false },
+  },
+  {
+    label: "同一モジュールの多重require (-m モード)",
+    fixture: "multi-require",
+    mode: { moduleLikeLua: true },
+  },
+  {
+    label: "エントリ直下で多数のrequire (-m モード, #12回帰防止)",
+    fixture: "entry-scope-many-requires",
+    mode: { moduleLikeLua: true },
+  },
+  {
+    label: "ビット演算子・整数除算の優先順序 (#27回帰防止)",
+    fixture: "bitwise-precedence",
+    mode: { moduleLikeLua: false },
+  },
+  {
+    label:
+      'require "m" (括弧なし文字列呼び出し構文) が解決される (-m モード, #18/#11修正確認)',
+    fixture: "require-string-call",
+    mode: { moduleLikeLua: true },
+  },
+  {
+    label:
+      "SLモードでrequireしたモジュールが文としてその場展開される (#18/#11修正確認)",
+    fixture: "require-call",
+    mode: { moduleLikeLua: false },
+  },
+  {
+    label:
+      "SLモードで同一モジュールを多重requireすると呼び出しごとに独立して文展開される (#18/#11修正確認)",
+    fixture: "multi-require",
+    mode: { moduleLikeLua: false },
+  },
+  {
+    label:
+      "SLモードで戻り値を使わない単独のrequire文はdofileと同様functionで包まずそのまま展開される (#29対応確認)",
+    fixture: "bare-require",
+    mode: { moduleLikeLua: false },
+  },
+  {
+    label:
+      "SLモードでrequireが式の一部（ネスト位置）に現れる場合はIIFEにフォールバックする (#29対応確認)",
+    fixture: "require-in-expression",
+    mode: { moduleLikeLua: false },
+  },
+  {
+    label:
+      "ドット区切りのモジュール名（サブディレクトリ）が解決される (-m モード, #21 Source Map確認)",
+    fixture: "nested-module",
+    mode: { moduleLikeLua: true },
+  },
+];
+
+// 既知バグの再現ケース。現状は failing のため `test.todo` で登録する。
+// 修正が入ったら .todo を外して WORKING_CASES に合流させること。
+export const KNOWN_BUG_CASES: KnownBugCase[] = [];

package/test/no-rename.test.ts

@@ -0,0 +1,19 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { runMinifier } from "./lib/helpers";
+
+// #20: CLIオプション(--no-rename)相当の`mode.rename = false`で識別子の短縮を
+// 無効化できることを確認する（デバッグ用途）。局所変数名は元のまま出力され、
+// 空白の除去などそれ以外のminify処理はそのまま行われる。
+void test("mode.rename = false disables identifier shortening", () => {
+  const { code } = runMinifier({
+    label: "single-file (no rename)",
+    fixture: "single-file",
+    mode: { moduleLikeLua: false, rename: false },
+  });
+
+  assert.match(code, /local function add\(first,second\)/);
+  assert.match(code, /local total=0/);
+  assert.match(code, /for index=1,10 do total=add\(total,index\)end/);
+  assert.match(code, /print\(total,i\)/);
+});

package/test/output.test.ts

@@ -0,0 +1,95 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import Parser from "luaparse";
+import { SourceNode } from "source-map";
+import { buildMinifiedOutput } from "../src/output";
+
+function makeNode(): SourceNode {
+  return new SourceNode(1, 0, "main.lua", "print(1)");
+}
+
+void test("buildMinifiedOutput: mapにfileフィールドが設定される", () => {
+  const { map } = buildMinifiedOutput(
+    makeNode(),
+    "main.min.lua",
+    "main.lua.map",
+  );
+
+  const parsed = JSON.parse(map) as { file?: string };
+  assert.equal(parsed.file, "main.min.lua");
+});
+
+// "legacy"（既定・未指定）: 旧storm-lua-minifyと完全に同じ複数行の`--[[ ]]`
+// ブロックコメントを出力する。互換性維持のため、既定はこの形式のままにする。
+void test('buildMinifiedOutput: 既定("legacy")は旧バージョンと同じ複数行ブロックコメントを出力し、有効なLuaのままである', () => {
+  const { code } = buildMinifiedOutput(
+    makeNode(),
+    "main.min.lua",
+    "main.lua.map",
+  );
+
+  assert.equal(code, "print(1)\n--[[\n//# sourceMappingURL=main.lua.map\n]]");
+  assert.doesNotThrow(() => Parser.parse(code, { luaVersion: "5.3" }));
+});
+
+void test('buildMinifiedOutput: sourceMappingUrlStyle: "legacy"を明示しても既定と同じ出力になる', () => {
+  const { code } = buildMinifiedOutput(
+    makeNode(),
+    "main.min.lua",
+    "main.lua.map",
+    {
+      sourceMappingUrlStyle: "legacy",
+    },
+  );
+
+  assert.equal(code, "print(1)\n--[[\n//# sourceMappingURL=main.lua.map\n]]");
+});
+
+// "line": 単一行の`--`ラインコメント。Source Map仕様の「アノテーションは
+// 最終行（末尾が空行の場合はその直前の行）に置く」というルールを満たしつつ、
+// 有効なLuaのままにするための妥協案。
+void test('buildMinifiedOutput: sourceMappingUrlStyle: "line"はsourceMappingURLが出力の最終行(末尾空行を除く)になり、有効なLuaのままである', () => {
+  const { code } = buildMinifiedOutput(
+    makeNode(),
+    "main.min.lua",
+    "main.lua.map",
+    {
+      sourceMappingUrlStyle: "line",
+    },
+  );
+
+  const lines = code.split("\n");
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  const lastLine = lines[lines.length - 1];
+
+  assert.equal(lastLine, "-- //# sourceMappingURL=main.lua.map");
+  assert.ok(lastLine.startsWith("--") && !lastLine.startsWith("--[["));
+  assert.doesNotThrow(() => Parser.parse(code, { luaVersion: "5.3" }));
+});
+
+// "strict": Luaコメントで一切包まず、Source Map仕様のマーカー文字列
+// (`//# sourceMappingURL=...`)をそのまま出力する。Lua 5.1〜5.4のいずれでも
+// `/`・`//`は二項演算子のトークンであり文の先頭には来られないため、この形式は
+// 有効なLuaと両立できない（調査の結果、回避不能と判断した）。この副作用を
+// テストで固定化しておく。
+void test('buildMinifiedOutput: sourceMappingUrlStyle: "strict"はLuaコメントで包まずアノテーションを出力し、Luaとしては構文エラーになる', () => {
+  const { code } = buildMinifiedOutput(
+    makeNode(),
+    "main.min.lua",
+    "main.lua.map",
+    {
+      sourceMappingUrlStyle: "strict",
+    },
+  );
+
+  const lines = code.split("\n");
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  const lastLine = lines[lines.length - 1];
+
+  assert.equal(lastLine, "//# sourceMappingURL=main.lua.map");
+  assert.throws(() => Parser.parse(code, { luaVersion: "5.3" }));
+});

package/test/precedence.test.ts

@@ -0,0 +1,28 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { runMinifier } from "./lib/helpers";
+
+// #27: PRECEDENCE テーブルにビット演算子(| ~ & << >>)と整数除算(//)が
+// 定義されておらず、比較結果が常に偽になることで必要な括弧が失われ、
+// 意味が変わってしまうバグの回帰防止テスト。
+// 括弧が必要な箇所では保持され、不要な箇所では省略されることを確認する。
+void test("ビット演算子・整数除算の優先順序が壊れない (#27)", () => {
+  const { code } = runMinifier({
+    label: "bitwise-precedence",
+    fixture: "bitwise-precedence",
+    mode: { moduleLikeLua: false },
+  });
+
+  // `&` は `|` より強いので、意味を変えずに括弧を省略できる
+  assert.match(code, /print\(a\|b&c\)/);
+  // `(a|b)&c` は括弧を落とすと意味が変わるため保持する必要がある
+  assert.match(code, /print\(\(a\|b\)&c\)/);
+  assert.match(code, /print\(a&b\|c\)/);
+  assert.match(code, /print\(a~b&c\)/);
+  // `+` は `<<` より強いので括弧を省略できる
+  assert.match(code, /print\(a<<b\+c\)/);
+  // `(a<<b)+c` は括弧を落とすと意味が変わるため保持する必要がある
+  assert.match(code, /print\(\(a<<b\)\+c\)/);
+  assert.match(code, /print\(a\/\/b\/\/c\)/);
+  assert.match(code, /print\(~a&b\)/);
+});

package/test/renamer.test.ts

@@ -0,0 +1,130 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import Parser from "luaparse";
+import { resolveScopes } from "../src/resolver";
+import { assignRenames } from "../src/renamer";
+
+// Renameパス（#20）の単体テスト。スコープに基づくスロット再利用、頻度順の名前割当、
+// 予約名との非衝突を検証する。
+
+function parse(code: string): Parser.Chunk {
+  return Parser.parse(code, { luaVersion: "5.3" });
+}
+
+void test("sibling scopes (non-overlapping) reuse the same short name", () => {
+  const chunk = parse(`
+    do
+      local x = 1
+      print(x)
+    end
+    do
+      local y = 2
+      print(y)
+    end
+  `);
+  const resolved = resolveScopes(chunk);
+  const result = assignRenames(resolved, new Set());
+
+  const firstDecl = (
+    (chunk.body[0] as Parser.DoStatement).body[0] as Parser.LocalStatement
+  ).variables[0];
+  const secondDecl = (
+    (chunk.body[1] as Parser.DoStatement).body[0] as Parser.LocalStatement
+  ).variables[0];
+
+  const firstName = result.nameOf(firstDecl);
+  const secondName = result.nameOf(secondDecl);
+  assert.ok(firstName);
+  assert.equal(firstName, secondName);
+});
+
+void test("symbols live in the same scope never receive the same short name", () => {
+  const chunk = parse(`
+    local a = 1
+    local b = 2
+    local c = 3
+    print(a, b, c)
+  `);
+  const resolved = resolveScopes(chunk);
+  const result = assignRenames(resolved, new Set());
+
+  const names = (chunk.body.slice(0, 3) as Parser.LocalStatement[]).map((s) =>
+    result.nameOf(s.variables[0]),
+  );
+  assert.equal(new Set(names).size, 3);
+});
+
+void test("more frequently referenced symbols get shorter names", () => {
+  const chunk = parse(`
+    local hot = 1
+    local cold = 2
+    print(hot, hot, hot, hot)
+    print(cold)
+  `);
+  const resolved = resolveScopes(chunk);
+  const result = assignRenames(resolved, new Set());
+
+  const hotDecl = (chunk.body[0] as Parser.LocalStatement).variables[0];
+  const coldDecl = (chunk.body[1] as Parser.LocalStatement).variables[0];
+
+  const hotName = result.nameOf(hotDecl);
+  const coldName = result.nameOf(coldDecl);
+  assert.ok(hotName);
+  assert.ok(coldName);
+  assert.ok(hotName.length <= coldName.length);
+  assert.notEqual(hotName, coldName);
+});
+
+void test("reserved names (globals/keywords) are never assigned to a symbol", () => {
+  const chunk = parse(`
+    local x = 1
+    print(x)
+  `);
+  const resolved = resolveScopes(chunk);
+  // "a" は本来最初に割り当てられるはずの名前。予約済みとして渡すと避けられる。
+  const result = assignRenames(resolved, new Set(["a"]));
+
+  const decl = (chunk.body[0] as Parser.LocalStatement).variables[0];
+  assert.notEqual(result.nameOf(decl), "a");
+});
+
+void test("self is never renamed and never assigned to another symbol", () => {
+  const chunk = parse(`
+    local function m(self, x)
+      return self, x
+    end
+  `);
+  const resolved = resolveScopes(chunk);
+  const result = assignRenames(resolved, new Set());
+
+  const fnDecl = chunk.body[0] as Parser.FunctionDeclaration;
+  const selfParam = fnDecl.parameters[0] as Parser.Identifier;
+  const xParam = fnDecl.parameters[1] as Parser.Identifier;
+
+  assert.equal(result.nameOf(selfParam), undefined);
+  assert.notEqual(result.nameOf(xParam), "self");
+});
+
+void test("usedNames reflects exactly the short names handed out", () => {
+  const chunk = parse(`
+    local x = 1
+    do
+      local y = 2
+      print(y)
+    end
+    print(x)
+  `);
+  const resolved = resolveScopes(chunk);
+  const result = assignRenames(resolved, new Set());
+
+  const xDecl = (chunk.body[0] as Parser.LocalStatement).variables[0];
+  const yDecl = (
+    (chunk.body[1] as Parser.DoStatement).body[0] as Parser.LocalStatement
+  ).variables[0];
+
+  const xName = result.nameOf(xDecl);
+  const yName = result.nameOf(yDecl);
+  assert.ok(xName);
+  assert.ok(yName);
+  assert.deepEqual(result.usedNames, new Set([xName, yName]));
+});