storm-lua-minify 0.1.2 → 0.2.0

package/test/resolver.test.ts

@@ -0,0 +1,206 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import Parser from "luaparse";
+import { resolveScopes } from "../src/resolver";
+
+// Resolveパス（#19）の単体テスト。宣言と参照の対応、シャドーイング、グローバル判定を検証する。
+// このパスは出力を変更しないため、ここでは解析結果のみを検証する。
+
+function parse(code: string): Parser.Chunk {
+  return Parser.parse(code, { luaVersion: "5.3" });
+}
+
+void test("resolves references to their declaring local symbol", () => {
+  const chunk = parse(`
+    local x = 1
+    print(x)
+    x = 2
+  `);
+  const result = resolveScopes(chunk);
+
+  const declaration = (chunk.body[0] as Parser.LocalStatement).variables[0];
+  const declSymbol = result.symbolOf(declaration);
+  assert.ok(declSymbol);
+  assert.equal(declSymbol.kind, "local");
+
+  const printArg = (
+    (chunk.body[1] as Parser.CallStatement).expression as Parser.CallExpression
+  ).arguments[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(printArg), declSymbol);
+
+  const assignTarget = (chunk.body[2] as Parser.AssignmentStatement)
+    .variables[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(assignTarget), declSymbol);
+
+  assert.deepEqual(
+    declSymbol.references.map((r) => r.name),
+    ["x", "x"],
+  );
+});
+
+void test("shadowed locals in a nested block resolve to a distinct symbol", () => {
+  const chunk = parse(`
+    local x = 1
+    do
+      local x = 2
+      print(x)
+    end
+    print(x)
+  `);
+  const result = resolveScopes(chunk);
+
+  const outerDecl = (chunk.body[0] as Parser.LocalStatement).variables[0];
+  const outerSymbol = result.symbolOf(outerDecl);
+
+  const doStatement = chunk.body[1] as Parser.DoStatement;
+  const innerDecl = (doStatement.body[0] as Parser.LocalStatement).variables[0];
+  const innerSymbol = result.symbolOf(innerDecl);
+
+  assert.ok(outerSymbol);
+  assert.ok(innerSymbol);
+  assert.notEqual(innerSymbol, outerSymbol);
+
+  const innerPrintArg = (
+    (doStatement.body[1] as Parser.CallStatement)
+      .expression as Parser.CallExpression
+  ).arguments[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(innerPrintArg), innerSymbol);
+
+  const outerPrintArg = (
+    (chunk.body[2] as Parser.CallStatement).expression as Parser.CallExpression
+  ).arguments[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(outerPrintArg), outerSymbol);
+});
+
+void test("re-declaring a local in the same block shadows only subsequent references", () => {
+  const chunk = parse(`
+    local x = 1
+    print(x)
+    local x = 2
+    print(x)
+  `);
+  const result = resolveScopes(chunk);
+
+  const firstSymbol = result.symbolOf(
+    (chunk.body[0] as Parser.LocalStatement).variables[0],
+  );
+  const secondSymbol = result.symbolOf(
+    (chunk.body[2] as Parser.LocalStatement).variables[0],
+  );
+  assert.ok(firstSymbol);
+  assert.ok(secondSymbol);
+  assert.notEqual(firstSymbol, secondSymbol);
+
+  const firstPrintArg = (
+    (chunk.body[1] as Parser.CallStatement).expression as Parser.CallExpression
+  ).arguments[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(firstPrintArg), firstSymbol);
+
+  const secondPrintArg = (
+    (chunk.body[3] as Parser.CallStatement).expression as Parser.CallExpression
+  ).arguments[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(secondPrintArg), secondSymbol);
+});
+
+void test("a function parameter shadows an outer local of the same name", () => {
+  const chunk = parse(`
+    local x = 1
+    local function f(x)
+      return x
+    end
+  `);
+  const result = resolveScopes(chunk);
+
+  const outerSymbol = result.symbolOf(
+    (chunk.body[0] as Parser.LocalStatement).variables[0],
+  );
+  const fnDecl = chunk.body[1] as Parser.FunctionDeclaration;
+  const paramSymbol = result.symbolOf(
+    fnDecl.parameters[0] as Parser.Identifier,
+  );
+  assert.ok(outerSymbol);
+  assert.ok(paramSymbol);
+  assert.notEqual(paramSymbol, outerSymbol);
+  assert.equal(paramSymbol.kind, "param");
+
+  const returnArg = (fnDecl.body[0] as Parser.ReturnStatement)
+    .arguments[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(returnArg), paramSymbol);
+});
+
+void test("a local function can refer to itself recursively", () => {
+  const chunk = parse(`
+    local function fact(n)
+      if n <= 1 then return 1 end
+      return n * fact(n - 1)
+    end
+  `);
+  const result = resolveScopes(chunk);
+
+  const fnDecl = chunk.body[0] as Parser.FunctionDeclaration;
+  const declSymbol = result.symbolOf(fnDecl.identifier as Parser.Identifier);
+  assert.ok(declSymbol);
+  assert.equal(declSymbol.kind, "local");
+
+  const returnStatement = fnDecl.body[1] as Parser.ReturnStatement;
+  const multiplyExpr = returnStatement.arguments[0] as Parser.BinaryExpression;
+  const callExpr = multiplyExpr.right as Parser.CallExpression;
+  const callee = callExpr.base as Parser.Identifier;
+  assert.equal(result.symbolOf(callee), declSymbol);
+});
+
+void test("a numeric for-loop variable is scoped to the loop body only", () => {
+  const chunk = parse(`
+    for i = 1, 10 do
+      print(i)
+    end
+    print(i)
+  `);
+  const result = resolveScopes(chunk);
+
+  const forStatement = chunk.body[0] as Parser.ForNumericStatement;
+  const loopVarSymbol = result.symbolOf(forStatement.variable);
+  assert.ok(loopVarSymbol);
+  assert.equal(loopVarSymbol.kind, "for");
+
+  const insideArg = (
+    (forStatement.body[0] as Parser.CallStatement)
+      .expression as Parser.CallExpression
+  ).arguments[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(insideArg), loopVarSymbol);
+
+  // ループの外側にある同名の参照は、ループ変数のシンボルとは無関係でグローバル扱いになる
+  const afterArg = (
+    (chunk.body[1] as Parser.CallStatement).expression as Parser.CallExpression
+  ).arguments[0] as Parser.Identifier;
+  assert.equal(result.symbolOf(afterArg), undefined);
+  assert.ok(result.globals.has("i"));
+});
+
+void test("unresolved identifiers are collected as globals, not symbols, and field/key names are ignored", () => {
+  const chunk = parse(`
+    screen.setColor(1, 2, 3)
+    local w, h = screen.getWidth(), screen.getHeight()
+    local t = { x = 1 }
+  `);
+  const result = resolveScopes(chunk);
+
+  // "screen" はどこにも宣言されていないためグローバル参照が3回集計される
+  const screenBinding = result.globals.get("screen");
+  assert.ok(screenBinding);
+  assert.equal(screenBinding.references.length, 3);
+
+  // フィールド名（setColor/getWidth/getHeight）やテーブルキー名（x）は
+  // 変数参照ではないため、グローバルにもシンボルにも現れない
+  assert.equal(result.globals.size, 1);
+  assert.ok(!result.symbols.some((s) => s.name === "screen"));
+  assert.ok(!result.symbols.some((s) => s.name === "x"));
+
+  assert.deepEqual(
+    result.symbols
+      .filter((s) => s.kind === "local")
+      .map((s) => s.name)
+      .sort(),
+    ["h", "t", "w"],
+  );
+});

package/test/roundtrip.test.ts

@@ -0,0 +1,26 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import Parser from "luaparse";
+import { WORKING_CASES, KNOWN_BUG_CASES, runMinifier } from "./lib/helpers";
+
+// minifyされたコードが再度luaparseでパース可能であることを検証する
+// （luaparseが例外を投げないこと = 少なくとも構文として壊れていないこと）。
+
+for (const c of WORKING_CASES) {
+  void test(`round-trip parse: ${c.label}`, () => {
+    const { code } = runMinifier(c);
+    assert.doesNotThrow(() => Parser.parse(code, { luaVersion: "5.3" }));
+  });
+}
+
+for (const c of KNOWN_BUG_CASES) {
+  const issue = String(c.issue);
+  void test(
+    `round-trip parse (known bug, issue #${issue}): ${c.label}`,
+    { todo: `#${issue} の本修正待ち` },
+    () => {
+      const { code } = runMinifier(c);
+      assert.doesNotThrow(() => Parser.parse(code, { luaVersion: "5.3" }));
+    },
+  );
+}

package/test/snapshot.test.ts

@@ -0,0 +1,27 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "fs";
+import path from "path";
+import { WORKING_CASES, runMinifier, slug, SNAPSHOTS_DIR } from "./lib/helpers";
+
+// UPDATE_SNAPSHOTS=1 npm test でゴールデンファイルを更新できる。
+const UPDATE = process.env.UPDATE_SNAPSHOTS === "1";
+
+for (const c of WORKING_CASES) {
+  void test(`snapshot: ${c.label}`, () => {
+    const { code } = runMinifier(c);
+    const snapshotPath = path.join(SNAPSHOTS_DIR, `${slug(c)}.lua`);
+
+    if (UPDATE) {
+      fs.writeFileSync(snapshotPath, code);
+      return;
+    }
+
+    assert.ok(
+      fs.existsSync(snapshotPath),
+      `スナップショットが存在しません: ${snapshotPath}\nUPDATE_SNAPSHOTS=1 npm test で生成してください。`,
+    );
+    const expected = fs.readFileSync(snapshotPath, "utf8");
+    assert.equal(code, expected);
+  });
+}

package/test/snapshots/bare-require.sl.lua

@@ -0,0 +1 @@
+print("hello from mod")print("done")

package/test/snapshots/bitwise-precedence.sl.lua

@@ -0,0 +1,2 @@
+local a,b,c=1,2,3
+print(a|b&c)print((a|b)&c)print(a&b|c)print(a~b&c)print(a<<b+c)print((a<<b)+c)print(a//b//c)print(~a&b)

package/test/snapshots/dofile.sl.lua

@@ -0,0 +1 @@
+print("hello from greet")print("done")

package/test/snapshots/entry-scope-many-requires.m.lua

@@ -0,0 +1,14 @@
+function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end
+if m=="dep_alpha"then r=(function() local a="dep_alpha"return{id=a} end)()end
+if m=="dep_bravo"then r=(function() local b="dep_bravo"return{id=b} end)()end
+if m=="dep_charlie"then r=(function() local c="dep_charlie"return{id=c} end)()end
+if m=="dep_delta"then r=(function() local d="dep_delta"return{id=d} end)()end
+if m=="dep_echo"then r=(function() local e="dep_echo"return{id=e} end)()end
+if m=="dep_foxtrot"then r=(function() local f="dep_foxtrot"return{id=f} end)()end
+if m=="dep_golf"then r=(function() local g="dep_golf"return{id=g} end)()end
+if m=="dep_hotel"then r=(function() local h="dep_hotel"return{id=h} end)()end
+if m=="dep_india"then r=(function() local i="dep_india"return{id=i} end)()end
+if m=="dep_juliet"then r=(function() local j="dep_juliet"return{id=j} end)()end
+if m=="dep_kilo"then r=(function() local k="dep_kilo"return{id=k} end)()end
+package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end
+local l=require("dep_alpha")local m=require("dep_bravo")local n=require("dep_charlie")local o=require("dep_delta")local p=require("dep_echo")local q=require("dep_foxtrot")local r=require("dep_golf")local s=require("dep_hotel")local t=require("dep_india")local u=require("dep_juliet")local v=require("dep_kilo")print(l,m,n,o,p,q,r,s,t,u,v)

package/test/snapshots/multi-require.m.lua

@@ -0,0 +1,4 @@
+function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end
+if m=="common"then r=(function() return{value=42} end)()end
+package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end
+local a=require("common")local b=require("common")print(a.value,b.value)

package/test/snapshots/multi-require.sl.lua

@@ -0,0 +1 @@
+local a={value=42}local b={value=42}print(a.value,b.value)

package/test/snapshots/nested-module.m.lua

@@ -0,0 +1,4 @@
+function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end
+if m=="sub.deep"then r=(function() return{value=1} end)()end
+package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end
+local a=require("sub.deep")print(a.value)

package/test/snapshots/require-call.m.lua

@@ -0,0 +1,5 @@
+function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end
+if m=="mod"then r=(function() local function a()return"hello"end
+return{hello=a} end)()end
+package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end
+local b=require("mod")print(b.hello())

package/test/snapshots/require-call.sl.lua

@@ -0,0 +1 @@
+local function a()return"hello"end local b={hello=a}print(b.hello())

package/test/snapshots/require-in-expression.sl.lua

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

package/test/snapshots/require-string-call.m.lua

@@ -0,0 +1,5 @@
+function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end
+if m=="mod"then r=(function() local function a()return"hello"end
+return{hello=a} end)()end
+package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end
+local b=require"mod"print(b.hello())

package/test/snapshots/single-file.sl.lua

@@ -0,0 +1,6 @@
+local function d(b,e)return b+e end
+local c=0
+for b=1,10 do c=d(c,b)end
+local a=0
+while a<3 do a=a+1 end
+print(c,a)

package/test/sourcemap.test.ts

@@ -0,0 +1,105 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "fs";
+import { SourceMapConsumer } from "source-map";
+import { fixtureEntryPath, runMinifier } from "./lib/helpers";
+
+// 生成コード中の`needle`が何回目に出現する行・列(source-map準拠: 行は1始まり、
+// 列は0始まり)かを求める。複数モジュールが1つの出力にまとめられるケースで、
+// 由来モジュールごとに異なる出現箇所を指定できるようにするため。
+function locateInGenerated(
+  code: string,
+  needle: string,
+  occurrence = 0,
+): { line: number; column: number } {
+  const lines = code.split("\n");
+  let seen = 0;
+  for (let i = 0; i < lines.length; i++) {
+    let from = 0;
+    for (;;) {
+      const column = lines[i].indexOf(needle, from);
+      if (column === -1) {
+        break;
+      }
+      if (seen === occurrence) {
+        return { line: i + 1, column };
+      }
+      seen++;
+      from = column + 1;
+    }
+  }
+  throw new Error(
+    `"${needle}" (occurrence ${String(occurrence)}) not found in generated code:\n${code}`,
+  );
+}
+
+void test("sourcemap: mapファイルにfileフィールドが設定される", () => {
+  const { map } = runMinifier({
+    fixture: "multi-require",
+    mode: { moduleLikeLua: true },
+  });
+  assert.equal(map.file, "multi-require.min.lua");
+});
+
+void test("sourcemap: sourcesContentに各モジュールの元テキストがそのまま埋め込まれる", async () => {
+  const { map } = runMinifier({
+    fixture: "multi-require",
+    mode: { moduleLikeLua: true },
+  });
+
+  await SourceMapConsumer.with(map, null, (consumer) => {
+    assert.ok(consumer.hasContentsOfAllSources());
+    const mainContent = consumer.sourceContentFor("main.lua");
+    const commonContent = consumer.sourceContentFor("common.lua");
+    assert.equal(
+      mainContent,
+      fs.readFileSync(fixtureEntryPath("multi-require", "main.lua"), "utf8"),
+    );
+    assert.equal(
+      commonContent,
+      fs.readFileSync(fixtureEntryPath("multi-require", "common.lua"), "utf8"),
+    );
+  });
+});
+
+void test("sourcemap: 別モジュール由来のトークンがそれぞれ正しい元ファイル・位置にマップされる", async () => {
+  const { code, map } = runMinifier({
+    fixture: "multi-require",
+    mode: { moduleLikeLua: false },
+  });
+  // SLモードでは同一モジュールへの多重requireがそれぞれ独立して展開されるため、
+  // "local a={value=42}local b={value=42}print(a.value,b.value)" のような形になる
+  // （test/snapshots/multi-require.sl.lua 参照）。
+
+  await SourceMapConsumer.with(map, null, (consumer) => {
+    // common.lua由来: 1回目のインライン展開の `42`
+    const firstValue = locateInGenerated(code, "42", 0);
+    const firstValuePos = consumer.originalPositionFor(firstValue);
+    assert.equal(firstValuePos.source, "common.lua");
+    assert.equal(firstValuePos.line, 1);
+
+    // common.lua由来: 2回目のインライン展開の `42`（1回目とは別のSourceNodeインスタンス）
+    const secondValue = locateInGenerated(code, "42", 1);
+    const secondValuePos = consumer.originalPositionFor(secondValue);
+    assert.equal(secondValuePos.source, "common.lua");
+    assert.equal(secondValuePos.line, 1);
+
+    // main.lua由来: print呼び出し
+    const printCall = locateInGenerated(code, "print");
+    const printPos = consumer.originalPositionFor(printCall);
+    assert.equal(printPos.source, "main.lua");
+    assert.equal(printPos.line, 3);
+    assert.equal(printPos.name, "print");
+  });
+});
+
+void test("sourcemap: ドット区切りモジュール名のsourcesはOSに依存せず'/'区切りになる", () => {
+  const { map } = runMinifier({
+    fixture: "nested-module",
+    mode: { moduleLikeLua: true },
+  });
+  assert.ok(
+    map.sources.includes("sub/deep.lua"),
+    `sources に "sub/deep.lua" が含まれていること。実際: ${JSON.stringify(map.sources)}`,
+  );
+});

package/tsconfig.eslint.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./",
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}