storm-lua-minify 0.2.0 → 0.9.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Nona Takahara, Mathias Bynens
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 Nona Takahara, Mathias Bynens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,37 +1,157 @@
-# storm-lua-minify
-
-このプログラムは [mathiasbynens/luamin](https://github.com/mathiasbynens/luamin) をベースにした Stormworks: Build and Rescue 向けのLua minifierです。
-
-Stormworks: Build and Rescue 以外の用途にも使用可能です。
-
-# 使い方
-
-```
-npm i storm-lua-minify
-
-npx storm-lua-minify script.lua
-```
-
-- `-m`オプションを付加すると、モジュールの挙動をLuaの実際の挙動に近づけます
-
-# テスト
-
-```
-npm ci
-npm run build
-npm test
-```
-
-# Lint / Format
-
-```
-npm run lint          # ESLint
-npm run format:check  # Prettierのフォーマットチェック
-npm run format        # Prettierでフォーマット
-```
-
-`test/` 以下にスナップショット・ラウンドトリップパース・識別子衝突検知のテストがあります。
-既知バグ（#11, #12 など）の再現ケースは `test.todo` として登録されており、`npm test` は成功しますが、
-修正が入るまではそのテスト自体は失敗した状態のまま todo 扱いになります。
-
-スナップショットを更新する場合は `UPDATE_SNAPSHOTS=1 npm test` を実行してください。
+# storm-lua-minify
+
+このプログラムは [mathiasbynens/luamin](https://github.com/mathiasbynens/luamin) をベースにした Stormworks: Build and Rescue 向けのLua minifierです。
+
+Stormworks: Build and Rescue 以外の用途にも使用可能です。
+
+# 使い方
+
+```
+npm i storm-lua-minify
+
+npx storm-lua-minify script.lua
+```
+
+## `require`の展開モード
+
+- オプションを設定しないと `require` / `dofile` 先を呼び出し位置へ直接展開する、Stormworks向けLuaを外部で作成する場合に馴染みのある方式となります。
+  - ただし、実装上の制約により、文中で `require` を使用するとfunctionで包んで展開されることがあるので注意してください。
+- `-m` / `--require-wrapper`は、`require`の挙動を通常のLuaに近づけます。
+  - 冒頭に`require`関数を定義し、モジュールはそこに展開されます。
+
+## コンパイル進捗
+
+対話環境で起動すると、現在のファイル、ステップ番号、処理段階を示す表示が出ます。内部処理の分岐によってステップ数の最大値が途中で増減することがあります。
+
+- `--no-progress`で進捗表示を無効化できます。
+  - パイプやCIなどの非対話環境では既定で無効です。
+- 非対話環境でも`--progress`を指定するとステップの開始と完了を通常のログ行として標準エラーへ出力します。
+
+## 最適化アノテーション
+
+### EmmyLuaアノテーション
+
+EmmyLuaの`class`／継承、`field`、`param`／`return`／`type`、`alias`／`enum`を最適化解析のヒントとして使用します。
+
+### 保護アノテーション（独自）
+
+宣言の直前（空行を挟まない位置）に、次のアノテーションを指定できます。
+
+- `--@storm export`: Luaコード外から名前で参照される宣言として、未使用削除と名前短縮の双方から保護します
+- `--@storm keep`: 未使用削除から保護しますが、名前短縮は許可します
+- `--@storm keep-name`: 名前短縮から保護しますが、未使用なら削除を許可します
+
+未知の`--@storm`指示や引数付きの指示は、エラーになります。
+
+## 最適化オプション
+
+最適化オプションは、**個別スイッチ**と**機能グループ**の階層構造を持ち、すべての最適化オプションのスイッチに肯定形と否定形があります。
+
+また、最適化オプションとは別に、Luaの動作に仮定を置くことで圧縮強度を高める設定（**仮定モード**）があります。仮定モードは最適化オプションとは別のレイヤーの設定です。
+
+```console
+storm-lua-minify --function-optimizations --no-function-inlining script.lua
+storm-lua-minify --no-optimizations --local-renaming script.lua
+```
+
+設定ファイルはコマンドと同じキーを使い、平坦に書きます。設定ファイルを使用する際は明示的に`--config`オプションで指定してください。
+
+各オプションの優先度は、コマンド指定値(個別スイッチ) > コマンド指定値(機能グループ) > 設定ファイル指定値(個別スイッチ) > 設定ファイル指定値(機能グループ) > 既定値の順です。
+
+```json
+{
+  "runtime-profile": "stormworks",
+  "function-optimizations": false,
+  "function-inlining": true,
+  "global-renaming": true,
+  "never-rename-globals": ["onTick", "onDraw"]
+}
+```
+
+```console
+storm-lua-minify --config storm-lua-minify.json --no-function-inlining script.lua
+```
+
+### 仮定モード
+
+`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文ではなくなる                   |
+
+# 開発者向けガイド
+
+開発環境の構築、テスト構成、最適化を追加するときの判断基準、`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 [];
+    }
+}