storm-lua-minify 0.1.2 → 0.2.0

package/src/cli.ts

@@ -1,56 +1,86 @@
-#!/usr/bin/env node
-
-import fs from "fs";
-import path from "path";
-import { Command } from "commander";
-import { Options } from "luaparse";
-import { Minifier, MinifierMode } from "./minifier";
-
-const program = new Command();
-
-program
-  .version("0.1.2")
-  .description("A Lua minifier also outputs source map")
-  .option(
-    "-m, --module-like-lua",
-    "require・dofileの動作を実際のLuaに近づけます"
-  );
-
-program.parse(process.argv);
-
-const luaFiles = program.args;
-
-const luaparseSetting: Partial<Options> = {
-  locations: true,
-  luaVersion: "5.3",
-  ranges: true,
-  scope: true,
-};
-
-const mode: MinifierMode = program.opts();
-
-luaFiles.forEach((fileName) => {
-  const parsedFileName = path.parse(fileName);
-
-  if (fs.existsSync(fileName)) {
-    const map = new Minifier(fileName, luaparseSetting, mode).parse();
-    const minFileName = path.format({
-      dir: parsedFileName.dir,
-      name: parsedFileName.name + ".min",
-      ext: ".lua",
-    });
-    const mapFileName = path.format({
-      dir: parsedFileName.dir,
-      name: parsedFileName.name,
-      ext: parsedFileName.ext + ".map",
-    });
-    map.add("\n--[[\n//# sourceMappingURL=" + mapFileName + "\n]]");
-
-    const sourceAndMap = map.toStringWithSourceMap();
-
-    fs.writeFileSync(minFileName, sourceAndMap.code);
-    fs.writeFileSync(mapFileName, JSON.stringify(sourceAndMap.map));
-  } else {
-    console.error("No such file: " + fileName);
-  }
-});
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import { Command } from "commander";
+import { Options } from "luaparse";
+import { Minifier, MinifierMode } from "./minifier";
+import { buildMinifiedOutput, SourceMappingUrlStyle } from "./output";
+
+const program = new Command();
+
+program
+  .version("0.1.3")
+  .description("A Lua minifier also outputs source map")
+  .option(
+    "-m, --module-like-lua",
+    "require・dofileの動作を実際のLuaに近づけます",
+  )
+  .option("--no-rename", "識別子の短縮(リネーム)を無効にします（デバッグ用途）")
+  .option(
+    "--single-line-source-mapping-url",
+    "sourceMappingURLアノテーションを単一行の--コメントで出力します（Source Map仕様の「最終行」ルールに従いますが、既定の複数行ブロックコメント形式を前提とするツールとは組み合わせられません）",
+  )
+  .option(
+    "--strict-source-mapping-url",
+    "sourceMappingURLアノテーションをLuaコメントで一切包まず、Source Map仕様のマーカー文字列(//# sourceMappingURL=...)そのままを出力します。Luaの文法上この形式と有効なLuaコードは両立できないため、出力ファイルの最終行は有効なLua文ではなくなります",
+  );
+
+program.parse(process.argv);
+
+const luaFiles = program.args;
+
+const luaparseSetting: Partial<Options> = {
+  locations: true,
+  luaVersion: "5.3",
+  ranges: true,
+  scope: true,
+};
+
+interface CliOptions extends MinifierMode {
+  singleLineSourceMappingUrl?: boolean;
+  strictSourceMappingUrl?: boolean;
+}
+
+const {
+  singleLineSourceMappingUrl,
+  strictSourceMappingUrl,
+  ...mode
+}: CliOptions = program.opts();
+
+// 既定は旧バージョンと互換の複数行ブロックコメント("legacy")。
+// --strict-source-mapping-url > --single-line-source-mapping-url の優先順で上書きする。
+const sourceMappingUrlStyle: SourceMappingUrlStyle = strictSourceMappingUrl
+  ? "strict"
+  : singleLineSourceMappingUrl
+    ? "line"
+    : "legacy";
+
+luaFiles.forEach((fileName) => {
+  const parsedFileName = path.parse(fileName);
+
+  if (fs.existsSync(fileName)) {
+    const map = new Minifier(fileName, luaparseSetting, mode).parse();
+    const minFileName = path.format({
+      dir: parsedFileName.dir,
+      name: parsedFileName.name + ".min",
+      ext: ".lua",
+    });
+    const mapFileName = path.format({
+      dir: parsedFileName.dir,
+      name: parsedFileName.name,
+      ext: parsedFileName.ext + ".map",
+    });
+    const { code, map: mapJson } = buildMinifiedOutput(
+      map,
+      minFileName,
+      mapFileName,
+      { sourceMappingUrlStyle },
+    );
+
+    fs.writeFileSync(minFileName, code);
+    fs.writeFileSync(mapFileName, mapJson);
+  } else {
+    console.error("No such file: " + fileName);
+  }
+});

package/src/linker.ts

@@ -0,0 +1,108 @@
+import { Chunk } from "./ast2lua";
+
+export interface ModuleReference {
+  kind: "require" | "dofile";
+  moduleName: string;
+}
+
+/**
+ * Chunk配下を型を問わず再帰的に走査するジェネリックウォーカー。
+ * printerとは独立に、AST全体からrequire/dofile呼び出しを見つけ出すために使う（#18）。
+ */
+function walk(node: unknown, visit: (n: Record<string, unknown>) => void) {
+  if (node === null || typeof node !== "object") {
+    return;
+  }
+  if (Array.isArray(node)) {
+    node.forEach((child) => {
+      walk(child, visit);
+    });
+    return;
+  }
+  const obj = node as Record<string, unknown>;
+  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: string): string {
+  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;
+}
+
+export function staticStringArgument(node: unknown): string | undefined {
+  if (
+    node !== null &&
+    typeof node === "object" &&
+    (node as Record<string, unknown>).type === "StringLiteral" &&
+    typeof (node as Record<string, unknown>).raw === "string"
+  ) {
+    return unquoteRaw((node as Record<string, unknown>).raw as string);
+  }
+  return undefined;
+}
+
+function calleeName(node: unknown): string | undefined {
+  if (
+    node !== null &&
+    typeof node === "object" &&
+    (node as Record<string, unknown>).type === "Identifier" &&
+    typeof (node as Record<string, unknown>).name === "string"
+  ) {
+    return (node as Record<string, unknown>).name as string;
+  }
+  return undefined;
+}
+
+/**
+ * ASTを走査してrequire/dofile呼び出し（CallExpression / StringCallExpression の両構文）を
+ * 静的な文字列引数付きのものに限って列挙する。同一モジュールへの参照は重複したまま返す
+ * （呼び出し側で重複排除する）。
+ */
+export function findModuleReferences(ast: Chunk): ModuleReference[] {
+  const refs: ModuleReference[] = [];
+
+  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/src/minifier.ts

@@ -1,114 +1,284 @@
-import Parser, { Comment, Options } from "luaparse";
-import path from "path";
-import fs from "fs";
-import { SourceNode } from "source-map";
-import { Chunk, MinifyFile } from "./ast2lua";
-
-export interface MinifierMode {
-  moduleLikeLua: boolean;
-}
-
-export class Minifier {
-  readonly identifierMap: Map<string, string>;
-  readonly identifiersInUse: Set<string>;
-  readonly moduleSourceText: Map<string, string>;
-  readonly moduleSourceNode: Map<string, SourceNode>;
-  readonly moduleAST: Map<string, Chunk>;
-  readonly dir: string;
-  readonly entryModule: string;
-  readonly mode: MinifierMode;
-  readonly luaParseSettings: Partial<Options>;
-
-  constructor(
-    entryFilePath: string,
-    luaParseSettings: Partial<Options>,
-    mode: MinifierMode
-  ) {
-    this.identifierMap = new Map<string, string>();
-    this.identifiersInUse = new Set<string>();
-    this.moduleSourceText = new Map<string, string>();
-    this.moduleSourceNode = new Map<string, SourceNode>();
-    this.moduleAST = new Map<string, Chunk>();
-    this.luaParseSettings = luaParseSettings;
-    this.mode = mode;
-    const pn = path.parse(entryFilePath);
-    this.dir = pn.dir;
-    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 as
-      | Comment[]
-      | undefined;
-    if (comments) {
-      comments
-        .reverse()
-        .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
-        .forEach((comment) => {
-          sn.prepend([
-            new SourceNode(
-              comment.loc?.start.line || null,
-              comment.loc?.start.column || null,
-              this.entryModule, // 本当に自分のファイル名でよいかは要検討
-              comment.raw
-            )
-          ,"\n"]);
-        });
-    }
-
-    return sn;
-  }
-
-  parseModule(moduleName: string): SourceNode {
-    const resolvePath = moduleName.replaceAll(".", path.sep) + ".lua";
-    const fullResolvePath = path.join(this.dir, resolvePath);
-
-    if (this.moduleSourceNode.has(moduleName)) {
-      const res = this.moduleSourceNode.get(moduleName);
-      if (res) {
-        return res;
-      }
-    } else if (fs.existsSync(fullResolvePath)) {
-      const code = fs.readFileSync(fullResolvePath).toString();
-      const ast = Parser.parse(code, this.luaParseSettings) as Chunk;
-      if ("globals" in ast) {
-        ast.globals?.map((v) => this.identifiersInUse.add(v.name));
-
-        const sourceNode = new MinifyFile(
-          resolvePath,
-          ast,
-          this,
-          this.mode
-        ).parse(resolvePath === this.entryModule);
-
-        this.moduleSourceText.set(moduleName, code);
-        this.moduleAST.set(moduleName, ast);
-        this.moduleSourceNode.set(moduleName, sourceNode);
-        return sourceNode;
-      }
-    }
-    throw new Error(moduleName + " is not found");
-  }
-}
+import Parser, { Options } from "luaparse";
+import path from "path";
+import fs from "fs";
+import { SourceNode } from "source-map";
+import { Chunk, MinifyFile } from "./ast2lua";
+import { findModuleReferences } from "./linker";
+import { resolveScopes, ResolveResult } from "./resolver";
+import { assignRenames, RenameResult } from "./renamer";
+
+export interface MinifierMode {
+  moduleLikeLua: boolean;
+  // 識別子の短縮(リネーム)を行うかどうか。デバッグ用途でfalseにできる。省略時はtrue扱い。
+  rename?: boolean;
+}
+
+const NO_RENAME: RenameResult = {
+  nameOf: () => undefined,
+  usedNames: new Set(),
+};
+
+export class Minifier {
+  readonly identifiersInUse: Set<string>;
+  readonly moduleSourceText: Map<string, string>;
+  readonly moduleAST: Map<string, Chunk>;
+  readonly moduleNameAndFileName: Map<string, string>;
+  readonly dir: string;
+  readonly entryModule: string;
+  readonly mode: MinifierMode;
+  readonly luaParseSettings: Partial<Options>;
+
+  // Linkパスで解決されたモジュール名を、依存されている側が先に来る順序で並べたもの
+  private readonly linkOrder: string[] = [];
+  // モジュールごとのResolveパスの結果（Linkパスで一度だけ計算し使い回す）
+  private readonly moduleResolve = new Map<string, ResolveResult>();
+  // モジュールごとのRenameパスの結果（初回アクセス時に計算しキャッシュする）
+  private readonly renameCache = new Map<string, RenameResult>();
+
+  constructor(
+    entryFilePath: string,
+    luaParseSettings: Partial<Options>,
+    mode: MinifierMode,
+  ) {
+    this.identifiersInUse = new Set<string>();
+    this.moduleSourceText = new Map<string, string>();
+    this.moduleAST = new Map<string, Chunk>();
+    this.moduleNameAndFileName = new Map<string, string>();
+    this.luaParseSettings = luaParseSettings;
+    this.mode = mode;
+    const pn = path.parse(entryFilePath);
+    this.dir = pn.dir;
+    this.entryModule = pn.name;
+  }
+
+  parse(): SourceNode {
+    this.link();
+    this.renameAll();
+
+    const parts: (SourceNode | string)[] = [];
+
+    const entryComments = this.moduleAST.get(this.entryModule)?.comments;
+    if (entryComments) {
+      entryComments
+        .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
+        .forEach((comment) => {
+          parts.push(
+            new SourceNode(
+              comment.loc?.start.line ?? null,
+              comment.loc?.start.column ?? null,
+              this.moduleNameAndFileName.get(this.entryModule) ?? null,
+              comment.raw,
+            ),
+            "\n",
+          );
+        });
+    }
+
+    if (this.mode.moduleLikeLua) {
+      parts.push(this.buildRequireWrapper());
+    }
+
+    parts.push(this.printModule(this.entryModule));
+
+    const result = new 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: string): SourceNode {
+    return this.printModule(moduleName);
+  }
+
+  /**
+   * requireを式（IIFE）ではなく文として展開できる場合に使う。モジュール本体が
+   * 「単一の式を返すreturn文」で終わっている場合のみ結果を返す。それ以外は
+   * undefinedを返すので、呼び出し側は従来のIIFE方式にフォールバックする（#29）。
+   */
+  splitModuleForStatementSplice(
+    moduleName: string,
+  ): { statements: SourceNode; finalExpression: SourceNode } | undefined {
+    const ast = this.moduleAST.get(moduleName);
+    const fileName = this.moduleNameAndFileName.get(moduleName);
+    if (!ast || !fileName) {
+      throw new Error(moduleName + " is not found");
+    }
+    return new MinifyFile(
+      fileName,
+      moduleName,
+      ast,
+      this,
+      this.mode,
+    ).parseAsStatementsAndFinalExpression(moduleName === this.entryModule);
+  }
+
+  /**
+   * 指定モジュールのRenameパス結果を返す。`renameAll`で事前に計算済みの
+   * ものをそのまま返すだけの参照用アクセサ。
+   */
+  getRenameResult(moduleName: string): RenameResult {
+    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;
+  }
+
+  /**
+   * Renameパス（#20）: linkOrder（依存されている側が先）の順にモジュールごとの
+   * 短縮名を割り当てる。
+   *
+   * dofileやSLモードのrequireその場展開は、呼び出し元と同じLuaスコープに
+   * 関数で包まずに直接展開されるため、モジュールをまたいで同じ短縮名を
+   * 再利用すると本来無関係な変数同士が衝突しうる（#12）。これを安全に防ぐため、
+   * あるモジュールが実際に使った短縮名は、後続モジュールを処理する前に
+   * `identifiersInUse`（予約名の集合）へ積み増す。これにより短縮名は
+   * プログラム全体で重複しなくなる（モジュール間での再利用による圧縮は
+   * 犠牲になるが、モジュール内でのスコープに基づく再利用は維持される）。
+   */
+  private 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 = assignRenames(resolved, this.identifiersInUse);
+      this.renameCache.set(moduleName, result);
+      result.usedNames.forEach((name) => this.identifiersInUse.add(name));
+    });
+  }
+
+  private printModule(moduleName: string): SourceNode {
+    const ast = this.moduleAST.get(moduleName);
+    const fileName = this.moduleNameAndFileName.get(moduleName);
+    if (!ast || !fileName) {
+      throw new Error(moduleName + " is not found");
+    }
+    return new MinifyFile(fileName, moduleName, ast, this, this.mode).parse(
+      moduleName === this.entryModule,
+    );
+  }
+
+  /**
+   * エントリファイルから到達可能な全モジュールをASTレベルで解決するLinkパス（#18）。
+   * - ファイルごとのパースは一度だけ行う（同一モジュールの多重require/dofileの重複排除）
+   * - require/dofileの参照グラフに循環があればエラーを投げる
+   * - 出力（Print）を開始する前に、必要なモジュール解決をすべて完了させる
+   */
+  private link() {
+    const visiting = new Set<string>();
+    const stack: string[] = [];
+
+    const visit = (moduleName: string) => {
+      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.join(this.dir, ...moduleName.split(".")) + ".lua";
+      if (!fs.existsSync(fullResolvePath)) {
+        throw new Error(moduleName + " is not found");
+      }
+      const code = fs.readFileSync(fullResolvePath).toString();
+      const ast = Parser.parse(code, this.luaParseSettings) as Chunk;
+
+      // Resolveパス（#19）: このモジュールのスコープ/シンボルを解析し、Renameパスの
+      // 入力として使い回せるようキャッシュする。グローバル参照はプログラム全体で
+      // 予約すべき名前（identifiersInUse）としてここで集計する。
+      const resolved = 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",
+      );
+
+      findModuleReferences(ast).forEach((ref) => {
+        visit(ref.moduleName);
+      });
+
+      visiting.delete(moduleName);
+      stack.pop();
+      this.linkOrder.push(moduleName);
+    };
+
+    visit(this.entryModule);
+  }
+
+  /**
+   * require()（dofileは除く）で参照されているモジュール名の集合を求める。
+   * dofileは呼び出しごとに毎回展開しなおすため、キャッシュ／ホイストの対象にしない。
+   */
+  private collectRequireTargets(): Set<string> {
+    const targets = new Set<string>();
+    this.linkOrder.forEach((moduleName) => {
+      const ast = this.moduleAST.get(moduleName);
+      if (!ast) {
+        return;
+      }
+      findModuleReferences(ast).forEach((ref) => {
+        if (ref.kind === "require") {
+          targets.add(ref.moduleName);
+        }
+      });
+    });
+    return targets;
+  }
+
+  private buildRequireWrapper(): SourceNode {
+    const targets = this.collectRequireTargets();
+    const parts: (SourceNode | string)[] = [
+      "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 SourceNode(null, null, null, parts);
+  }
+}