storm-lua-minify 0.3.0 → 0.9.0

package/README.md

@@ -12,68 +12,146 @@ npm i storm-lua-minify
 npx storm-lua-minify script.lua
 ```
 
-- `-m`オプションを付加すると、モジュールの挙動をLuaの実際の挙動に近づけます
+## `require`の展開モード
 
-# Source Map
+- オプションを設定しないと `require` / `dofile` 先を呼び出し位置へ直接展開する、Stormworks向けLuaを外部で作成する場合に馴染みのある方式となります。
+  - ただし、実装上の制約により、文中で `require` を使用するとfunctionで包んで展開されることがあるので注意してください。
+- `-m` / `--require-wrapper`は、`require`の挙動を通常のLuaに近づけます。
+  - 冒頭に`require`関数を定義し、モジュールはそこに展開されます。
 
-このツールは、ミニファイ後のコードと合わせて [Source Map](https://tc39.es/source-map/) (`.lua.map`) を出力します。
+## コンパイル進捗
 
-## sourceMappingURLアノテーションの出力形式
+対話環境で起動すると、現在のファイル、ステップ番号、処理段階を示す表示が出ます。内部処理の分岐によってステップ数の最大値が途中で増減することがあります。
 
-出力される `.min.lua` の末尾に付く `sourceMappingURL` アノテーションの書式は、3種類から選べます。
-
-| オプション                         | 書式                                        | 特徴                                                                                                                                                       |
-| ---------------------------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| （既定）                           | 複数行の `--[[`〜`]]` ブロックコメント      | 過去のバージョンと同じ出力。既存ツールとの互換性を優先する場合はこのまま使う                                                                               |
-| `--single-line-source-mapping-url` | 単一行の `--` ラインコメント                | 有効なLuaのまま、Source Map仕様が定める「アノテーションは生成コードの最終行に置く」という規則を満たす                                                      |
-| `--strict-source-mapping-url`      | Luaコメントで包まないマーカー文字列そのまま | 規則を厳密に満たすが、出力ファイルの最終行は有効なLua文ではなくなる（Lua文法上、`//`から始まる行をコメント化なしに構文解析可能にする方法は存在しないため） |
+- `--no-progress`で進捗表示を無効化できます。
+  - パイプやCIなどの非対話環境では既定で無効です。
+- 非対話環境でも`--progress`を指定するとステップの開始と完了を通常のログ行として標準エラーへ出力します。
 
-「最終行に置く」規則を厳密な前提とするツール（生成コードの末尾だけを見て `sourceMappingURL` を解決する実装など）と組み合わせる場合は、`--single-line-source-mapping-url` を試してください。
+## 最適化アノテーション
 
-## sourcesContent
+### EmmyLuaアノテーション
 
-`.lua.map` の `sourcesContent` には、エントリファイルおよび `require`/`dofile` で参照される全モジュールの元テキストがそのまま埋め込まれます。ビューア側で元の `.lua` ファイルに個別にアクセスできなくても、Source Mapファイル単体で元コードを参照できます。
+EmmyLuaの`class`／継承、`field`、`param`／`return`／`type`、`alias`／`enum`を最適化解析のヒントとして使用します。
 
-## キーワードトークンのマッピング
+### 保護アノテーション（独自）
 
-識別子・リテラル・式などASTノードに対応する出力は、それぞれ元ソース上の対応する位置に正確にマッピングされます。加えて、`then`/`elseif`/`else`/`end`/`do`/`until` といった、AST上では文・式の境界としてしか位置を持たないキーワードについても、それぞれが実際に出現する位置に個別にマッピングされます（例: `if`〜`then`〜`end` の `then` と `end` は、`if` とは別の、それぞれ自身の出現位置を持ちます）。トークン単位で対応関係を表示するビューアと組み合わせる際は、この粒度でのマッピングが利用されます。
+宣言の直前（空行を挟まない位置）に、次のアノテーションを指定できます。
 
-## 識別子短縮関連のオプション
+- `--@storm export`: Luaコード外から名前で参照される宣言として、未使用削除と名前短縮の双方から保護します
+- `--@storm keep`: 未使用削除から保護しますが、名前短縮は許可します
+- `--@storm keep-name`: 名前短縮から保護しますが、未使用なら削除を許可します
 
-既定では以下がすべて有効です。デバッグ用途や意図しない出力になった場合は個別に無効化できます。
+未知の`--@storm`指示や引数付きの指示は、エラーになります。
 
-- `--no-rename`: すべての識別子短縮を無効にします
-- `--no-merge-locals`: 連続する`local`変数宣言のまとめ上げを無効にします
-- `--no-global-rename`: 代入されている（＝スクリプト内部でのみ使われている）グローバル識別子の短縮を無効にします
-- `--no-global-alias`: 短縮できない外部グローバル識別子（`screen`など、代入されず参照のみされるもの）を、頻出する場合にローカル変数へ代入して短縮する最適化を無効にします
-- `--reserved-globals-config <path>`: `{"neverRenameGlobals": ["name", ...]}`形式のJSONファイルを指定し、**代入されていても常にリネームしないグローバル名**を列挙します
+## 最適化オプション
 
-### ⚠️ `--reserved-globals-config` について（重要）
+最適化オプションは、**個別スイッチ**と**機能グループ**の階層構造を持ち、すべての最適化オプションのスイッチに肯定形と否定形があります。
 
-`--no-global-rename`が有効な場合、このツールは「プログラム中のどこかで代入されているグローバル名」を自動的に内部専用とみなしてリネームします。これは通常のスクリプト内部の状態変数には安全ですが、**実行環境（エンジンなど）が特定の名前のグローバル関数・変数を探して呼び出す規約がある場合、その名前を誤ってリネームしてしまうと、静かに（エラーなく）呼び出されなくなるバグになります**。
+また、最適化オプションとは別に、Luaの動作に仮定を置くことで圧縮強度を高める設定（**仮定モード**）があります。仮定モードは最適化オプションとは別のレイヤーの設定です。
 
-そのような規約（例: Stormworksのマイクロコントローラーでエンジン側が呼び出す特定名のコールバック関数など）が対象のスクリプトにある場合は、必ず`--reserved-globals-config`でその名前を保護対象として指定してください。規約を把握していない場合は、安全のため`--no-global-rename`で本機能自体を無効にすることを推奨します。
+```console
+storm-lua-minify --function-optimizations --no-function-inlining script.lua
+storm-lua-minify --no-optimizations --local-renaming script.lua
+```
 
-# 開発・テスト
+設定ファイルはコマンドと同じキーを使い、平坦に書きます。設定ファイルを使用する際は明示的に`--config`オプションで指定してください。
 
-開発はpnpmに変更になっています（v0.3.0リリース時点より）
+各オプションの優先度は、コマンド指定値(個別スイッチ) > コマンド指定値(機能グループ) > 設定ファイル指定値(個別スイッチ) > 設定ファイル指定値(機能グループ) > 既定値の順です。
 
+```json
+{
+  "runtime-profile": "stormworks",
+  "function-optimizations": false,
+  "function-inlining": true,
+  "global-renaming": true,
+  "never-rename-globals": ["onTick", "onDraw"]
+}
 ```
-pnpm ci
-pnpm run build
-pnpm test
+
+```console
+storm-lua-minify --config storm-lua-minify.json --no-function-inlining script.lua
 ```
 
-# Lint / Format
+### 仮定モード
 
-```
-pnpm run lint          # ESLint
-pnpm run format:check  # Prettierのフォーマットチェック
-pnpm run format        # Prettierでフォーマット
-```
+`runtime-profile`の影響を受けます。`runtime-profile`は、コマンドでは`stormworks`が既定です。ライブラリAPIで省略した場合は`lua53`として扱います。
+
+これらの機能は実際のコードに対して、圧縮が強まる仮定を置く機能です。仮定が誤っているとコードの結果が変化することがあるため、注意してください。
+
+| 仮定                                  | 既定                             | 説明                                                                                                                                                                         |
+| ------------------------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `allow-introspection-changes`         | `lua53`: OFF<br>`stormworks`: ON | local名・生存期間、parameter、stack frameなどdebug APIから観測できる変更を許可します。<br>**現時点では`stormworks`プロファイルではOFFできません**                            |
+| `assume-annotations`                  | OFF                              | EmmyLuaアノテーションを最適化の変換根拠として信頼します                                                                                                                      |
+| `allow-observable-table-read-changes` | OFF                              | テーブルから読み取ってlocal変数を初期化する処理について、テーブルへの書き込み前へ移動する候補を許可します。local変数の値がテーブルへの書き込み前の値に変わる可能性があります |
+
+### 個別スイッチ
+
+| スイッチ                               | 既定    | 説明                                              |
+| -------------------------------------- | ------- | ------------------------------------------------- |
+| `local-renaming`                       | ON      | local名を短くします                               |
+| `local-name-reuse`                     | ON      | 生存期間が重ならないlocalで同じ名前を再利用します |
+| `global-renaming`                      | **OFF** | 内部で使うglobal名を短くします（※1）              |
+| `field-renaming`                       | ON      | 安全に変更できるfield名を短くします               |
+| `global-aliasing`                      | ON      | 繰り返し参照するglobalへ短いlocal名を割り当てます |
+| `local-declaration-merging`            | ON      | 連続するlocal宣言をまとめます                     |
+| `local-declaration-hoisting`           | ON      | local宣言を移動してまとめやすくします             |
+| `table-read-merging`                   | ON      | tableを読み取るlocal宣言をまとめます              |
+| `field-sensitive-table-effects`        | ON      | tableへの書き込みの影響をfield単位で判定します    |
+| `constant-expression-evaluation`       | **OFF** | 定数だけからなる式を事前に計算します              |
+| `local-constant-propagation`           | **OFF** | 再代入されないlocalの定数を参照先へ伝えます       |
+| `interprocedural-constant-propagation` | **OFF** | 関数の呼び出しを越えて定数を伝えます              |
+| `parameter-pruning`                    | ON      | 使われない関数parameterを取り除きます             |
+| `function-inlining`                    | ON      | 関数呼び出しを関数本体で置き換えます              |
+| `function-specialization`              | ON      | 呼び出し方に合わせて関数を特殊化します            |
+| `field-value-propagation`              | ON      | 安定したfieldの値を参照先へ伝えます               |
+| `unused-local-removal`                 | ON      | 未使用のlocalを取り除きます                       |
+| `unused-function-removal`              | ON      | 未使用のlocal関数を取り除きます                   |
+| `unused-field-initializer-removal`     | ON      | 読み取られないfieldの初期化を取り除きます         |
+| `unused-export-removal`                | ON      | entryから到達できないmodule exportを取り除きます  |
+
+安全性の条件を満たさない候補は、スイッチが有効でも実行されません。
+
+#### `--global-renaming` から短縮を保護する（※1）
+
+`--global-renaming`を有効にすると、このツールは「プログラム中のどこかで代入されているグローバル名」を内部専用とみなしてリネームします。
+これは通常のスクリプト内部の状態変数には安全ですが、**実行環境が直接呼び出す関数名・変数名をうまく検出できません**。
+
+短縮から保護する必要がある名前を`never-rename-globals`へ列挙するか、前述の`--@storm export`によって保護してください。
+コマンドでは`--name-rename-globals <保護名>`を繰り返し記述します。設定ファイルでは`never-rename-globals`に保護する名前の配列を与えます。
+
+### 機能グループ
+
+機能グループのスイッチを設定すると、個別スイッチをまとめてオンオフします。
+
+| 機能グループ               | 個別スイッチ                                                                                                     |
+| -------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `optimizations`            | 以下の全機能グループ（他の機能グループ設定の方が優先されます）                                                   |
+| `identifier-optimizations` | `local-renaming`, `local-name-reuse`, `global-renaming`, `field-renaming`, `global-aliasing`                     |
+| `statement-optimizations`  | `local-declaration-merging`, `local-declaration-hoisting`, `table-read-merging`, `field-sensitive-table-effects` |
+| `constant-optimizations`   | `constant-expression-evaluation`, `local-constant-propagation`, `interprocedural-constant-propagation`           |
+| `function-optimizations`   | `parameter-pruning`, `function-inlining`, `function-specialization`                                              |
+| `object-optimizations`     | `field-value-propagation`                                                                                        |
+| `dead-code-optimizations`  | `unused-code-removal`, `unused-export-removal`                                                                   |
+| `unused-code-removal`      | `unused-local-removal`, `unused-function-removal`, `unused-field-initializer-removal`                            |
+
+## Source Map
+
+このツールは、圧縮後のコードと合わせて [Source Map](https://tc39.es/source-map/) (`.lua.map`) を出力します。
+
+`.lua.map` の `sourcesContent` には、エントリファイルおよび `require`/`dofile` で参照される全モジュールの元テキストがそのまま埋め込まれますので、Source Mapファイル単体で元コードを参照できます。
+
+### sourceMappingURLアノテーションの出力形式
+
+出力される `.min.lua` の末尾に付く `sourceMappingURL` アノテーションの書式は、3種類から選べます。
+
+[本ツール作者による紹介記事](https://nonasaba.net/blog/entry16.html)で紹介したツールでは、Luaコードとしての有効性を保ちながら認識させるには`legacy`を使う必要があるため、非標準動作を既定としています。
+
+| `--source-mapping-url-style` | 書式                                   | 特徴                                              |
+| ---------------------------- | -------------------------------------- | ------------------------------------------------- |
+| `legacy`（既定）             | 複数行の `--[[`〜`]]` ブロックコメント | 従来形式                                          |
+| `line`                       | 単一行の `--` ラインコメント           | 有効なLuaのままSource Map仕様の最終行規則を満たす |
+| `strict`                     | Luaコメントで包まないマーカー文字列    | 最終行は有効なLua文ではなくなる                   |
 
-`test/` 以下にスナップショット・ラウンドトリップパース・識別子衝突検知のテストがあります。
-既知バグ（#11, #12 など）の再現ケースは `test.todo` として登録されており、`npm test` は成功しますが、
-修正が入るまではそのテスト自体は失敗した状態のまま todo 扱いになります。
+# 開発者向けガイド
 
-スナップショットを更新する場合は `UPDATE_SNAPSHOTS=1 npm test` を実行してください。
+開発環境の構築、テスト構成、最適化を追加するときの判断基準、`scripts/`の調査・検証コマンドについては[開発者向けガイド](DEVELOPMENT.md)を参照してください。

package/dist/aggregateSpecialization.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAggregateSpecialization = applyAggregateSpecialization;
+const astWalk_1 = require("./astWalk");
+const generatedNode_1 = require("./generatedNode");
+const MAX_VARIANTS = 128;
+const MAX_CANDIDATE_SITES = 2048;
+/**
+ * Build one callable-oriented plan for direct, method, and stable-field calls.
+ * Every site is normalized to the callee parameter order; method receiver and
+ * callback base evaluation become explicit leading actuals before grouping.
+ */
+function applyAggregateSpecialization(objects, fields, modules) {
+    if (objects.generation !== fields.generation)
+        throw new Error("Cannot specialize mixed whole-program generations");
+    const moduleOfCallable = new Map();
+    objects.modules.forEach((module) => {
+        const target = modules.find((candidate) => candidate.name === module.name);
+        if (!target)
+            return;
+        module.analysis.callGraph.functions.forEach((callable) => moduleOfCallable.set(callable, target));
+    });
+    const moduleOfNode = new WeakMap();
+    modules.forEach((module) => {
+        indexNodes(module.chunk.body, module, moduleOfNode);
+    });
+    const methods = new Map(objects.resolvedMethods.map((method) => [method.call.call, method]));
+    const callbacks = new Map(fields.resolvedCallbacks.map((callback) => [callback.call.call, callback]));
+    const recursive = new Set(fields.callGraph.sccs
+        .filter((scc) => scc.recursive)
+        .flatMap((scc) => scc.functions));
+    const sitesByCallable = new Map();
+    fields.callGraph.calls.forEach((site) => {
+        if (site.hasUnknownTarget || site.targets.size !== 1)
+            return;
+        const callable = [...site.targets][0];
+        if (site.call.type !== "CallExpression")
+            return;
+        const module = moduleOfNode.get(site.owner);
+        if (!module)
+            return;
+        const method = methods.get(site.call);
+        const callback = callbacks.get(site.call);
+        let actuals = site.call.arguments;
+        let parameterOffset = 0;
+        if (method)
+            actuals = [method.receiver, ...site.call.arguments];
+        else if (callback && site.call.base.type === "MemberExpression") {
+            // Preserve evaluation of the callback receiver before its arguments.
+            actuals = [site.call.base.base, ...site.call.arguments];
+            parameterOffset = 1;
+        }
+        const normalized = sitesByCallable.get(callable) ?? [];
+        normalized.push({ site, callable, module, actuals, parameterOffset });
+        sitesByCallable.set(callable, normalized);
+    });
+    const constantParameters = inferConstantParameters(sitesByCallable);
+    const diagnostics = [];
+    const unavailableNames = new Set(modules.flatMap((module) => [
+        ...module.resolved.symbols.map((symbol) => symbol.name),
+        ...module.resolved.globals.keys(),
+    ]));
+    const callbackFields = new Map();
+    fields.facts.forEach((fact) => {
+        if (fact.value?.kind !== "function")
+            return;
+        const stored = callbackFields.get(fact.value.callable) ?? new Set();
+        stored.add(fact.field);
+        callbackFields.set(fact.value.callable, stored);
+        if (fact.invalidationReasons.has("field-reassignment"))
+            diagnostics.push({
+                callable: fact.value.callable,
+                reason: "callback-reassignment",
+                count: 1,
+            });
+        else if (fact.invalidationReasons.size > 0)
+            diagnostics.push({
+                callable: fact.value.callable,
+                reason: "dynamic-dispatch",
+                count: 1,
+            });
+    });
+    callbackFields.forEach((stored, callable) => {
+        if (stored.size > 1)
+            diagnostics.push({
+                callable,
+                reason: "multiple-callback-storage",
+                count: stored.size,
+            });
+    });
+    let candidateCallables = 0;
+    let createdVariants = 0;
+    let replacedCalls = 0;
+    const introducedByBody = new Map();
+    const totalSites = [...sitesByCallable.values()].reduce((sum, sites) => sum + sites.length, 0);
+    if (totalSites > MAX_CANDIDATE_SITES) {
+        sitesByCallable.forEach((_, callable) => diagnostics.push({ callable, reason: "resource-budget", count: 1 }));
+        return {
+            changed: false,
+            candidateCallables: sitesByCallable.size,
+            createdVariants: 0,
+            replacedCalls: 0,
+            diagnostics,
+        };
+    }
+    sitesByCallable.forEach((sites, callable) => {
+        const ownerModule = moduleOfCallable.get(callable);
+        if (!ownerModule || sites.length === 0)
+            return;
+        candidateCallables++;
+        const refusal = refusalOf(callable, sites, ownerModule, recursive);
+        if (refusal) {
+            diagnostics.push({ callable, reason: refusal, count: 1 });
+            return;
+        }
+        const groups = variantGroups(callable, sites, constantParameters);
+        groups.forEach((group) => {
+            if (createdVariants >= MAX_VARIANTS) {
+                diagnostics.push({ callable, reason: "resource-budget", count: 1 });
+                return;
+            }
+            const insertionModule = group.sites[0].module;
+            if (group.sites.some((site) => site.module !== insertionModule))
+                return;
+            const firstOwner = group.sites[0].site.owner;
+            const insertionBody = bodyContaining(insertionModule.chunk.body, firstOwner);
+            if (!insertionBody ||
+                group.sites.some((site) => bodyContaining(insertionModule.chunk.body, site.site.owner) !==
+                    insertionBody)) {
+                diagnostics.push({ callable, reason: "unknown-capture", count: 1 });
+                return;
+            }
+            const introduced = introducedByBody.get(insertionBody) ?? 0;
+            if (introduced >= insertionModule.maxIntroducedLocalsAt(firstOwner)) {
+                diagnostics.push({ callable, reason: "resource-budget", count: 1 });
+                return;
+            }
+            let variantIndex = createdVariants;
+            let variantName = `__stormVariant${String(variantIndex)}`;
+            while (unavailableNames.has(variantName)) {
+                variantIndex++;
+                variantName = `__stormVariant${String(variantIndex)}`;
+            }
+            unavailableNames.add(variantName);
+            const variant = makeVariant(callable, group, variantName, ownerModule);
+            if (!variant) {
+                diagnostics.push({ callable, reason: "unknown-capture", count: 1 });
+                return;
+            }
+            insertionBody.splice(insertionBody.indexOf(firstOwner), 0, variant);
+            introducedByBody.set(insertionBody, introduced + 1);
+            group.sites.forEach((normalized) => {
+                const call = normalized.site.call;
+                if (call.type !== "CallExpression")
+                    return;
+                const retainedActuals = normalized.actuals.filter((_, index) => {
+                    const parameterIndex = index - normalized.parameterOffset;
+                    return parameterIndex < 0 || !group.literals.has(parameterIndex);
+                });
+                const replacement = {
+                    type: "Identifier",
+                    name: variantName,
+                };
+                (0, generatedNode_1.copyNodeOrigin)(replacement, call.base);
+                call.base = replacement;
+                call.arguments = retainedActuals.map((actual) => structuredClone(actual));
+                replacedCalls++;
+            });
+            createdVariants++;
+            diagnostics.push({
+                callable,
+                reason: "variant-created",
+                count: group.sites.length,
+            });
+        });
+    });
+    return {
+        changed: createdVariants > 0,
+        candidateCallables,
+        createdVariants,
+        replacedCalls,
+        diagnostics,
+    };
+}
+function refusalOf(callable, sites, ownerModule, recursive) {
+    if (recursive.has(callable))
+        return "recursive-function";
+    if (callable.declaration.parameters.some((parameter) => parameter.type === "VarargLiteral"))
+        return "vararg-function";
+    if (callable.declaration.parameters.length === 0)
+        return "unsupported-shape";
+    const annotations = ownerModule.metadata.annotationsOf(callable.declaration);
+    if (annotations.keep || annotations.exported)
+        return "unsupported-shape";
+    if (!captureSafe(callable, sites, ownerModule))
+        return "unknown-capture";
+    return undefined;
+}
+function captureSafe(callable, sites, ownerModule) {
+    const resolved = ownerModule.resolved;
+    const functionScope = resolved.scopeOfFunction(callable.declaration);
+    if (!functionScope)
+        return false;
+    const state = { safe: true, captures: false };
+    callable.declaration.body.forEach((statement) => {
+        (0, astWalk_1.walkStatement)(statement, {
+            onIdentifierReference: (identifier) => {
+                const symbol = resolved.symbolOf(identifier);
+                if (symbol && !insideScope(symbol, functionScope))
+                    state.captures = true;
+            },
+            onFunction: () => {
+                state.safe = false;
+            },
+        });
+    });
+    return (state.safe &&
+        (!state.captures || sites.every((site) => site.module === ownerModule)));
+}
+function insideScope(symbol, scope) {
+    for (let current = symbol.scope; current; current = current.parent)
+        if (current === scope)
+            return true;
+    return false;
+}
+function variantGroups(callable, sites, constantParameters) {
+    const candidates = new Map();
+    sites.forEach((site) => {
+        callable.declaration.parameters.forEach((_, parameterIndex) => {
+            const actual = site.actuals.at(parameterIndex + site.parameterOffset);
+            const direct = primitiveLiteral(actual);
+            const actualSymbol = !direct && actual?.type === "Identifier"
+                ? site.module.resolved.symbolOf(actual)
+                : undefined;
+            const literal = direct ??
+                (actualSymbol ? constantParameters.get(actualSymbol) : undefined);
+            if (!literal)
+                return;
+            const key = `${String(parameterIndex)}:${literalKey(literal)}`;
+            const candidate = candidates.get(key) ?? {
+                parameterIndex,
+                literal,
+                sites: [],
+                derived: direct === undefined,
+            };
+            candidate.sites.push(site);
+            if (!direct)
+                candidate.derived = true;
+            candidates.set(key, candidate);
+        });
+    });
+    const assigned = new Set();
+    return [...candidates.entries()]
+        .filter(([, candidate]) => candidate.sites.length >= 2 || candidate.derived)
+        .sort(([leftKey, left], [rightKey, right]) => right.sites.length - left.sites.length ||
+        left.parameterIndex - right.parameterIndex ||
+        leftKey.localeCompare(rightKey))
+        .flatMap(([key, candidate]) => {
+        const grouped = candidate.sites.filter((site) => !assigned.has(site));
+        if (grouped.length < 2 && !candidate.derived)
+            return [];
+        grouped.forEach((site) => assigned.add(site));
+        return [
+            {
+                key,
+                sites: grouped,
+                literals: new Map([[candidate.parameterIndex, candidate.literal]]),
+            },
+        ];
+    });
+}
+function inferConstantParameters(sitesByCallable) {
+    const result = new Map();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        sitesByCallable.forEach((sites, callable) => {
+            callable.parameters.forEach((parameter, parameterIndex) => {
+                if (result.has(parameter) || sites.length === 0)
+                    return;
+                const values = sites.map((site) => {
+                    const actual = site.actuals.at(parameterIndex + site.parameterOffset);
+                    const direct = primitiveLiteral(actual);
+                    if (direct)
+                        return direct;
+                    if (!actual || actual.type !== "Identifier")
+                        return undefined;
+                    const symbol = site.module.resolved.symbolOf(actual);
+                    return symbol ? result.get(symbol) : undefined;
+                });
+                const first = values[0];
+                if (!first ||
+                    values.some((value) => !value || literalKey(value) !== literalKey(first)))
+                    return;
+                result.set(parameter, first);
+                changed = true;
+            });
+        });
+    }
+    return result;
+}
+function makeVariant(callable, group, name, ownerModule) {
+    const declaration = callable.declaration;
+    if (declaration.parameters.some((parameter) => parameter.type !== "Identifier"))
+        return undefined;
+    const copiedBody = declaration.body.map((statement) => structuredClone(statement));
+    replaceParameterReferences(declaration.body, copiedBody, ownerModule.resolved, new Map([...group.literals].map(([index, literal]) => [callable.parameters[index], literal])));
+    const parameters = declaration.parameters
+        .filter((_, index) => !group.literals.has(index))
+        .map((parameter) => structuredClone(parameter));
+    if (group.sites[0].parameterOffset > 0)
+        parameters.unshift({ type: "Identifier", name: "__stormReceiver" });
+    const identifier = { type: "Identifier", name };
+    (0, generatedNode_1.copyNodeOrigin)(identifier, declaration.identifier ?? declaration);
+    const variant = {
+        type: "FunctionDeclaration",
+        identifier,
+        isLocal: true,
+        parameters,
+        body: copiedBody,
+    };
+    (0, generatedNode_1.copyNodeOrigin)(variant, declaration);
+    return variant;
+}
+function replaceParameterReferences(originals, copies, resolved, literals) {
+    const visit = (original, copy) => {
+        if (!original ||
+            !copy ||
+            typeof original !== "object" ||
+            typeof copy !== "object")
+            return;
+        if (Array.isArray(original)) {
+            if (!Array.isArray(copy))
+                return;
+            original.forEach((item, index) => {
+                visit(item, copy[index]);
+            });
+            return;
+        }
+        if (original.type === "Identifier") {
+            const symbol = resolved.symbolOf(original);
+            const literal = symbol ? literals.get(symbol) : undefined;
+            if (literal)
+                Object.assign(copy, structuredClone(literal));
+            return;
+        }
+        Object.keys(original).forEach((key) => {
+            visit(original[key], copy[key]);
+        });
+    };
+    visit(originals, copies);
+}
+function primitiveLiteral(expression) {
+    if (!expression)
+        return { type: "NilLiteral", value: null, raw: "nil" };
+    switch (expression.type) {
+        case "StringLiteral":
+        case "NumericLiteral":
+        case "BooleanLiteral":
+        case "NilLiteral":
+            return expression;
+        default:
+            return undefined;
+    }
+}
+function literalKey(literal) {
+    return `${literal.type}:${literal.raw}`;
+}
+function indexNodes(body, module, index) {
+    const visit = (value) => {
+        if (!value || typeof value !== "object")
+            return;
+        index.set(value, module);
+        if (Array.isArray(value))
+            value.forEach(visit);
+        else
+            Object.values(value).forEach(visit);
+    };
+    visit(body);
+}
+function bodyContaining(body, owner) {
+    if (body.includes(owner))
+        return body;
+    for (const statement of body)
+        for (const child of childBlocks(statement)) {
+            const found = bodyContaining(child, owner);
+            if (found)
+                return found;
+        }
+    return undefined;
+}
+function childBlocks(statement) {
+    switch (statement.type) {
+        case "DoStatement":
+        case "WhileStatement":
+        case "RepeatStatement":
+        case "FunctionDeclaration":
+        case "ForNumericStatement":
+        case "ForGenericStatement":
+            return [statement.body];
+        case "IfStatement":
+            return statement.clauses.map((clause) => clause.body);
+        default:
+            return [];
+    }
+}