storm-lua-minify 0.3.0 → 0.9.0

package/dist/minifier.js

@@ -7,18 +7,43 @@ exports.Minifier = void 0;
 const luaparse_1 = __importDefault(require("luaparse"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const source_map_1 = require("source-map");
 const ast2lua_1 = require("./ast2lua");
 const linker_1 = require("./linker");
 const resolver_1 = require("./resolver");
 const renamer_1 = require("./renamer");
 const globalRename_1 = require("./globalRename");
 const transform_1 = require("./transform");
+const sourceMetadata_1 = require("./sourceMetadata");
+const removeUnused_1 = require("./removeUnused");
+const constantFold_1 = require("./constantFold");
+const generatedAst_1 = require("./generatedAst");
+const statementScheduler_1 = require("./statementScheduler");
+const optimizerPass_1 = require("./optimizerPass");
+const runtimeEnvironment_1 = require("./runtimeEnvironment");
+const optimizerDiagnostics_1 = require("./optimizerDiagnostics");
+const optimizerFacts_1 = require("./optimizerFacts");
+const optimizerAnalysis_1 = require("./optimizerAnalysis");
+const interproceduralConstants_1 = require("./interproceduralConstants");
+const functionRewrites_1 = require("./functionRewrites");
+const wholeProgramObjects_1 = require("./wholeProgramObjects");
+const wholeProgramFields_1 = require("./wholeProgramFields");
+const aggregateSpecialization_1 = require("./aggregateSpecialization");
+const wholeProgramExports_1 = require("./wholeProgramExports");
+const wholeProgramFieldRenames_1 = require("./wholeProgramFieldRenames");
+const options_1 = require("./options");
 const NO_RENAME = {
     nameOf: () => undefined,
     usedNames: new Set(),
 };
+function sourceRangeOf(node) {
+    return node.range;
+}
+function copyMap(source, target) {
+    target.clear();
+    source.forEach((value, key) => target.set(key, value));
+}
 class Minifier {
+    entryFilePath;
     identifiersInUse;
     moduleSourceText;
     moduleAST;
@@ -35,44 +60,931 @@ class Minifier {
     renameCache = new Map();
     // #8a: プログラム全体を横断して決定された「内部グローバル名 -> 短縮名」の対応
     globalRenames = new Map();
-    constructor(entryFilePath, luaParseSettings, mode) {
+    moduleMetadata = new Map();
+    diagnosticCollector;
+    schedulerVariant;
+    functionRewriteVariant;
+    fieldFactVariant;
+    aggregateSpecializationVariant;
+    exportDceVariant;
+    fieldRenameVariant;
+    progress;
+    linkedAstGeneration = 0;
+    wholeProgramObjectsValue;
+    wholeProgramFieldsValue;
+    wholeProgramExportsValue;
+    wholeProgramFieldRenamesValue;
+    exportDceChanged = false;
+    constructor(entryFilePath, luaParseSettings, mode, schedulerVariantOrProgress, functionRewriteVariant, fieldFactVariant, aggregateSpecializationVariant, exportDceVariant, fieldRenameVariant, progress) {
+        this.schedulerVariant =
+            typeof schedulerVariantOrProgress === "string"
+                ? schedulerVariantOrProgress
+                : undefined;
+        this.functionRewriteVariant = functionRewriteVariant;
+        this.fieldFactVariant = fieldFactVariant;
+        this.aggregateSpecializationVariant = aggregateSpecializationVariant;
+        this.exportDceVariant = exportDceVariant;
+        this.fieldRenameVariant = fieldRenameVariant;
+        this.progress =
+            typeof schedulerVariantOrProgress === "object"
+                ? schedulerVariantOrProgress
+                : progress;
+        this.entryFilePath = entryFilePath;
         this.identifiersInUse = new Set();
         this.moduleSourceText = new Map();
         this.moduleAST = new Map();
         this.moduleNameAndFileName = new Map();
-        this.luaParseSettings = luaParseSettings;
-        this.mode = mode;
+        // コメントの所有関係と自己再帰参照の判定は位置情報を不変条件とする。
+        // 呼び出し側が省略・無効化しても、内部パスに必要な情報は常に収集する。
+        this.luaParseSettings = {
+            ...luaParseSettings,
+            comments: true,
+            locations: true,
+            ranges: true,
+        };
+        this.mode = (0, options_1.resolveMinifierMode)(mode);
+        if (mode.collectOptimizationDiagnostics) {
+            this.diagnosticCollector = new optimizerDiagnostics_1.OptimizationDiagnosticCollector();
+        }
         const pn = path_1.default.parse(entryFilePath);
         this.dir = pn.dir;
         this.entryModule = pn.name;
     }
+    get optimizationDiagnostics() {
+        return this.diagnosticCollector?.diagnostics ?? [];
+    }
+    get wholeProgramObjects() {
+        return this.wholeProgramObjectsValue;
+    }
+    get wholeProgramFields() {
+        return this.wholeProgramFieldsValue;
+    }
+    get wholeProgramExports() {
+        return this.wholeProgramExportsValue;
+    }
+    get wholeProgramFieldRenames() {
+        return this.wholeProgramFieldRenamesValue;
+    }
     parse() {
+        if (this.fieldRenameVariant === undefined && this.fieldRenamesEnabled()) {
+            return this.parseWithFieldRenameSelection();
+        }
+        if (this.exportDceVariant === undefined && this.exportDceEnabled()) {
+            return this.parseWithExportDceSelection();
+        }
+        if (this.fieldFactVariant === undefined && this.fieldFactsEnabled()) {
+            return this.parseWithFieldFactSelection();
+        }
+        if (this.aggregateSpecializationVariant === undefined &&
+            this.functionSpecializationEnabled()) {
+            return this.parseWithAggregateSpecializationSelection();
+        }
+        if (this.functionRewriteVariant === undefined &&
+            this.functionRewritesEnabled()) {
+            return this.parseWithFunctionRewriteSelection();
+        }
+        if (this.schedulerVariant === undefined &&
+            this.requiresSchedulerSelection()) {
+            return this.parseWithSchedulerSelection();
+        }
+        return this.parseOnce();
+    }
+    parseWithFieldRenameSelection() {
+        this.progress?.addSteps(2);
+        this.progress?.startStep("Evaluate field renaming baseline");
+        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, undefined, "baseline", this.progress);
+        const baseline = baselineMinifier.parse();
+        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
+        let trialMinifier;
+        let trial;
+        try {
+            this.progress?.startStep("Evaluate field renaming trial");
+            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, undefined, "trial", this.progress);
+            trial = trialMinifier.parse();
+        }
+        catch {
+            this.copyDiagnosticsFrom(baselineMinifier);
+            this.recordFinalFieldRenameDecision("rejected", "trial-failed");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        const trialBytes = new TextEncoder().encode(trial.toString()).length;
+        if (trialBytes >= baselineBytes) {
+            this.copyDiagnosticsFrom(trialMinifier);
+            this.recordFinalFieldRenameDecision("rejected", "final-output-not-shorter");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        this.copyDiagnosticsFrom(trialMinifier);
+        this.recordFinalFieldRenameDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
+        return this.adoptVariant(trialMinifier, trial);
+    }
+    parseWithExportDceSelection() {
+        this.progress?.addSteps(1);
+        let trialMinifier;
+        let trial;
+        try {
+            this.progress?.startStep("Evaluate unused export removal trial");
+            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, "trial", this.fieldRenameVariant, this.progress);
+            trial = trialMinifier.parse();
+        }
+        catch {
+            this.progress?.addSteps(1);
+            this.progress?.startStep("Evaluate unused export removal baseline");
+            const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, "baseline", this.fieldRenameVariant, this.progress);
+            const baseline = baselineMinifier.parse();
+            this.copyDiagnosticsFrom(baselineMinifier);
+            this.recordFinalExportDceDecision("rejected", "trial-failed");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        if (!trialMinifier.exportDceChanged) {
+            this.copyDiagnosticsFrom(trialMinifier);
+            this.recordFinalExportDceDecision("rejected", "final-output-not-shorter");
+            return this.adoptVariant(trialMinifier, trial);
+        }
+        this.progress?.addSteps(1);
+        this.progress?.startStep("Evaluate unused export removal baseline");
+        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, "baseline", this.fieldRenameVariant, this.progress);
+        const baseline = baselineMinifier.parse();
+        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
+        const trialBytes = new TextEncoder().encode(trial.toString()).length;
+        if (trialBytes >= baselineBytes) {
+            this.copyDiagnosticsFrom(trialMinifier);
+            this.recordFinalExportDceDecision("rejected", "final-output-not-shorter");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        this.copyDiagnosticsFrom(trialMinifier);
+        this.recordFinalExportDceDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
+        return this.adoptVariant(trialMinifier, trial);
+    }
+    parseWithFieldFactSelection() {
+        this.progress?.addSteps(2);
+        this.progress?.startStep("Evaluate field optimization baseline");
+        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, "baseline", this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
+        const baseline = baselineMinifier.parse();
+        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
+        let trialMinifier;
+        let trial;
+        try {
+            this.progress?.startStep("Evaluate field optimization trial");
+            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, "trial", this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
+            trial = trialMinifier.parse();
+        }
+        catch {
+            this.copyDiagnosticsFrom(baselineMinifier);
+            this.recordFinalFieldFactDecision("rejected", "trial-failed");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        const trialBytes = new TextEncoder().encode(trial.toString()).length;
+        if (trialBytes >= baselineBytes) {
+            this.copyDiagnosticsFrom(trialMinifier);
+            this.recordFinalFieldFactDecision("rejected", "final-output-not-shorter");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        this.copyDiagnosticsFrom(trialMinifier);
+        this.recordFinalFieldFactDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
+        return this.adoptVariant(trialMinifier, trial);
+    }
+    parseWithAggregateSpecializationSelection() {
+        this.progress?.addSteps(2);
+        this.progress?.startStep("Evaluate function specialization baseline");
+        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, this.fieldFactVariant, "baseline", this.exportDceVariant, this.fieldRenameVariant, this.progress);
+        const baseline = baselineMinifier.parse();
+        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
+        let trialMinifier;
+        let trial;
+        try {
+            this.progress?.startStep("Evaluate function specialization trial");
+            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, this.fieldFactVariant, "trial", this.exportDceVariant, this.fieldRenameVariant, this.progress);
+            trial = trialMinifier.parse();
+        }
+        catch {
+            this.copyDiagnosticsFrom(baselineMinifier);
+            this.recordFinalAggregateSpecializationDecision("rejected", "trial-failed");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        const trialBytes = new TextEncoder().encode(trial.toString()).length;
+        if (trialBytes >= baselineBytes) {
+            this.copyDiagnosticsFrom(trialMinifier);
+            this.recordFinalAggregateSpecializationDecision("rejected", "final-output-not-shorter");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        this.copyDiagnosticsFrom(trialMinifier);
+        this.recordFinalAggregateSpecializationDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
+        return this.adoptVariant(trialMinifier, trial);
+    }
+    parseWithFunctionRewriteSelection() {
+        this.progress?.addSteps(2);
+        this.progress?.startStep("Evaluate function rewrites baseline");
+        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, "baseline", this.fieldFactVariant, this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
+        const baseline = baselineMinifier.parse();
+        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
+        let trialMinifier;
+        let trial;
+        try {
+            this.progress?.startStep("Evaluate function rewrites trial");
+            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, "trial", this.fieldFactVariant, this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
+            trial = trialMinifier.parse();
+        }
+        catch {
+            this.copyDiagnosticsFrom(baselineMinifier);
+            this.recordFinalFunctionRewriteDecision("rejected", "trial-failed");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        const trialBytes = new TextEncoder().encode(trial.toString()).length;
+        if (trialBytes >= baselineBytes) {
+            this.copyDiagnosticsFrom(trialMinifier);
+            this.recordFinalFunctionRewriteDecision("rejected", "final-output-not-shorter");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        this.copyDiagnosticsFrom(trialMinifier);
+        this.recordFinalFunctionRewriteDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
+        return this.adoptVariant(trialMinifier, trial);
+    }
+    parseWithSchedulerSelection() {
+        this.progress?.addSteps(2);
+        this.progress?.startStep("Evaluate statement scheduling baseline");
+        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, "baseline", this.functionRewriteVariant, this.fieldFactVariant, this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
+        const baseline = baselineMinifier.parseOnce();
+        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
+        let trialMinifier;
+        let trial;
+        try {
+            this.progress?.startStep("Evaluate statement scheduling trial");
+            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, "trial", this.functionRewriteVariant, this.fieldFactVariant, this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
+            trial = trialMinifier.parseOnce();
+        }
+        catch {
+            this.copyDiagnosticsFrom(baselineMinifier);
+            this.recordFinalSchedulerDecision("rejected", "trial-failed");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        const trialBytes = new TextEncoder().encode(trial.toString()).length;
+        if (trialBytes >= baselineBytes) {
+            this.copyDiagnosticsFrom(trialMinifier);
+            this.recordFinalSchedulerDecision("rejected", "final-output-not-shorter");
+            return this.adoptVariant(baselineMinifier, baseline);
+        }
+        this.copyDiagnosticsFrom(trialMinifier);
+        this.recordFinalSchedulerDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
+        return this.adoptVariant(trialMinifier, trial);
+    }
+    parseOnce() {
+        this.progress?.addSteps(11);
+        this.progress?.startStep("Load and parse modules");
         this.link();
+        this.progress?.tick();
+        // #85 consumes #84 function-valued field facts before field DCE can remove
+        // callback storage. The field pass then sees specialized calls and includes
+        // storage/wrapper cleanup in the same final-output trial.
+        this.progress?.startStep("Rewrite functions");
+        this.rewriteFunctionsAll();
+        this.progress?.tick();
+        this.progress?.startStep("Analyze and rewrite fields");
+        this.rewriteWholeProgramFieldsAll();
+        this.progress?.tick();
+        this.progress?.startStep("Fold constants");
+        this.foldConstantsAll();
+        this.progress?.tick();
+        this.progress?.startStep("Remove unused exports");
+        this.rewriteWholeProgramExportsAll();
+        this.progress?.tick();
+        this.progress?.startStep("Remove unused code");
+        this.removeUnusedAll();
+        this.progress?.tick();
+        this.progress?.startStep("Plan global names");
+        this.rebuildIdentifiersInUse();
         this.computeGlobalRenames();
+        this.progress?.tick();
+        this.progress?.startStep("Transform statements");
         this.transformAll();
-        this.renameAll();
-        const parts = [];
-        const entryComments = this.moduleAST.get(this.entryModule)?.comments;
-        if (entryComments) {
-            entryComments
-                .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
-                .forEach((comment) => {
-                parts.push(new source_map_1.SourceNode(comment.loc?.start.line ?? null, comment.loc?.start.column ?? null, this.moduleNameAndFileName.get(this.entryModule) ?? null, comment.raw), "\n");
+        this.progress?.tick();
+        this.progress?.startStep("Finalize whole-program analyses");
+        if (this.functionRewritesEnabled() ||
+            this.fieldFactsEnabled() ||
+            this.fieldRenamesEnabled()) {
+            // fold/remove/schedule may have changed any module after method rewrites. Publish only a
+            // snapshot rebuilt from the complete linked AST generation consumed by final Rename/Print.
+            this.linkedAstGeneration++;
+            this.wholeProgramObjectsValue = this.analyzeWholeProgramObjects();
+            this.wholeProgramFieldsValue = (0, wholeProgramFields_1.analyzeWholeProgramFields)(this.wholeProgramObjectsValue, {
+                trustAnnotations: this.mode.assumeAnnotations === true,
+                metadataOf: (moduleName) => this.getSourceMetadata(moduleName),
             });
+            this.wholeProgramExportsValue = (0, wholeProgramExports_1.analyzeWholeProgramExports)(this.wholeProgramObjectsValue, this.entryModule, (moduleName) => this.getSourceMetadata(moduleName));
+            if (this.fieldRenameVariant === "trial") {
+                this.wholeProgramFieldRenamesValue = (0, wholeProgramFieldRenames_1.planWholeProgramFieldRenames)(this.wholeProgramObjectsValue, this.wholeProgramFieldsValue, this.wholeProgramExportsValue, this.entryModule, (moduleName) => this.getSourceMetadata(moduleName));
+                this.recordWholeProgramFieldRenameDiagnostics(this.wholeProgramFieldRenamesValue);
+            }
         }
-        if (this.mode.moduleLikeLua) {
-            parts.push(this.buildRequireWrapper());
-        }
-        parts.push(this.printModule(this.entryModule));
-        const result = new source_map_1.SourceNode(null, null, null, parts);
+        this.progress?.tick();
+        this.progress?.startStep("Rename identifiers");
+        this.renameAll();
+        this.progress?.tick();
+        this.progress?.startStep("Generate Lua and source map");
+        const result = this.mode.requireWrapper
+            ? this.printModuleWithRequireWrapper()
+            : this.printModule(this.entryModule);
         this.moduleSourceText.forEach((v, k) => {
             const fileName = this.moduleNameAndFileName.get(k);
             if (fileName) {
                 result.setSourceContent(fileName, v);
             }
+            this.progress?.tick();
         });
         return result;
     }
+    rewriteWholeProgramExportsAll() {
+        if (this.exportDceVariant !== "trial" || !this.exportDceEnabled())
+            return;
+        const objectAnalysis = this.analyzeWholeProgramObjects();
+        const exportAnalysis = (0, wholeProgramExports_1.analyzeWholeProgramExports)(objectAnalysis, this.entryModule, (moduleName) => this.getSourceMetadata(moduleName));
+        this.wholeProgramObjectsValue = objectAnalysis;
+        this.wholeProgramExportsValue = exportAnalysis;
+        exportAnalysis.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+            pass: "whole-program-export-reachability",
+            moduleName: diagnostic.moduleName,
+            fieldName: diagnostic.field,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: diagnostic.reason === "export-field-candidate" ||
+                diagnostic.reason === "field-live" ||
+                diagnostic.reason === "field-unreachable"
+                ? "accepted"
+                : "rejected",
+            reason: diagnostic.reason,
+            candidateSize: 1,
+            sourceRange: diagnostic.sourceRange,
+        }));
+        const analysisByModule = new Map(objectAnalysis.modules.map((module) => [module.name, module.analysis]));
+        const result = (0, wholeProgramExports_1.applyWholeProgramExportDce)(exportAnalysis, (moduleName) => this.getSourceMetadata(moduleName), (moduleName, expression) => analysisByModule.get(moduleName)?.facts.discardabilityOf(expression)
+            .discardable === true);
+        result.refusedEffectfulInitializerFields.forEach((field) => this.diagnosticCollector?.record({
+            pass: "whole-program-export-dce",
+            moduleName: field.moduleName,
+            fieldName: field.key,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: "rejected",
+            reason: "effectful-initializer",
+            candidateSize: 1,
+        }));
+        if (!result.changed)
+            return;
+        this.exportDceChanged = true;
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            if (!ast)
+                throw new Error(moduleName + " is not found");
+            this.moduleResolve.set(moduleName, (0, resolver_1.resolveScopes)(ast));
+        });
+        this.linkedAstGeneration++;
+        this.wholeProgramObjectsValue = undefined;
+        this.wholeProgramFieldsValue = undefined;
+        this.wholeProgramExportsValue = undefined;
+        result.removedFields.forEach((field) => this.diagnosticCollector?.record({
+            pass: "whole-program-export-dce",
+            moduleName: field.moduleName,
+            fieldName: field.key,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: "accepted",
+            reason: "field-removed",
+            candidateSize: 1,
+        }));
+        result.preservedEffectFields.forEach((field) => this.diagnosticCollector?.record({
+            pass: "whole-program-export-dce",
+            moduleName: field.moduleName,
+            fieldName: field.key,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: "accepted",
+            reason: "field-effect-preserved",
+            candidateSize: 1,
+        }));
+    }
+    rewriteWholeProgramFieldsAll() {
+        if (this.fieldFactVariant === "baseline" || !this.fieldFactsEnabled())
+            return;
+        const objectAnalysis = this.analyzeWholeProgramObjects();
+        const fieldAnalysis = (0, wholeProgramFields_1.analyzeWholeProgramFields)(objectAnalysis, {
+            trustAnnotations: this.mode.assumeAnnotations === true,
+            metadataOf: (moduleName) => this.getSourceMetadata(moduleName),
+        });
+        this.wholeProgramObjectsValue = objectAnalysis;
+        this.wholeProgramFieldsValue = fieldAnalysis;
+        fieldAnalysis.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+            pass: "whole-program-constructor-fields",
+            moduleName: diagnostic.moduleName,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: diagnostic.reason === "field-fact" ? "accepted" : "rejected",
+            reason: diagnostic.reason,
+            candidateSize: 1,
+            sourceRange: diagnostic.sourceRange,
+        }));
+        const result = (0, wholeProgramFields_1.applyWholeProgramFieldRewrites)(objectAnalysis, fieldAnalysis, (moduleName) => this.getSourceMetadata(moduleName), {
+            replaceReads: this.mode.fieldValuePropagation,
+            removeInitializers: this.mode.unusedFieldInitializerRemoval,
+        });
+        if (!result.changed)
+            return;
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            if (!ast)
+                throw new Error(moduleName + " is not found");
+            const passes = new optimizerPass_1.PassOrchestrator(ast, (0, resolver_1.resolveScopes)(ast));
+            passes.runUntilStable("fold-constructor-field-constants", (resolved) => {
+                const facts = passes.analysis(optimizerFacts_1.OPTIMIZER_FACTS_CACHE_KEY, optimizerFacts_1.analyzeOptimizerFactsAtGeneration);
+                const changed = (0, constantFold_1.foldConstants)(ast, resolved, this.getSourceMetadata(moduleName), facts, {
+                    evaluateExpressions: this.mode.constantExpressionEvaluation,
+                    propagateLocals: this.mode.localConstantPropagation,
+                });
+                return { changed, invalidatesResolve: changed };
+            });
+            this.moduleResolve.set(moduleName, passes.resolved);
+        });
+        this.linkedAstGeneration++;
+        this.wholeProgramObjectsValue = undefined;
+        this.wholeProgramFieldsValue = undefined;
+        this.wholeProgramExportsValue = undefined;
+        this.diagnosticCollector?.record({
+            pass: "whole-program-constructor-field-rewrite",
+            moduleName: this.entryModule,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: "accepted",
+            reason: "field-rewrite-applied",
+            candidateSize: result.replacedReads + result.removedInitializers,
+        });
+        const recordRewrite = (reason, count) => {
+            if (count === 0)
+                return;
+            this.diagnosticCollector?.record({
+                pass: "whole-program-constructor-field-rewrite",
+                moduleName: this.entryModule,
+                runtimeProfile: this.mode.runtimeProfile,
+                decision: "accepted",
+                reason,
+                candidateSize: count,
+            });
+        };
+        recordRewrite("field-read-replaced", result.replacedReads);
+        recordRewrite("dead-field-write", result.removedInitializers);
+        recordRewrite("field-write-effect-preserved", result.preservedEffects);
+    }
+    /** Function-summary consumers run before scheduling and final rename/print. */
+    rewriteFunctionsAll() {
+        if (this.functionRewriteVariant === "baseline" ||
+            !this.functionRewritesEnabled())
+            return;
+        let initialWholeProgram = this.analyzeWholeProgramObjects();
+        this.recordWholeProgramObjectDiagnostics(initialWholeProgram);
+        const initiallyResolvedMethodDeclarations = new Set(initialWholeProgram.resolvedMethods.map((method) => method.target.declaration));
+        if (this.mode.functionSpecialization &&
+            this.aggregateSpecializationVariant !== "baseline") {
+            const initialFieldFacts = (0, wholeProgramFields_1.analyzeWholeProgramFields)(initialWholeProgram, {
+                trustAnnotations: this.mode.assumeAnnotations === true,
+                metadataOf: (moduleName) => this.getSourceMetadata(moduleName),
+            });
+            const specialization = (0, aggregateSpecialization_1.applyAggregateSpecialization)(initialWholeProgram, initialFieldFacts, this.linkOrder.map((name) => {
+                const chunk = this.moduleAST.get(name);
+                const resolved = this.moduleResolve.get(name);
+                if (!chunk || !resolved)
+                    throw new Error(name + " is not found");
+                const resources = (0, runtimeEnvironment_1.analyzeLocalResourceUsage)(chunk);
+                const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+                return {
+                    name,
+                    chunk,
+                    resolved,
+                    metadata: this.getSourceMetadata(name),
+                    maxIntroducedLocalsAt: (statement) => {
+                        const active = resources.activeLocalsBefore(statement);
+                        if (active === undefined)
+                            return 0;
+                        return Math.max(0, Math.min(runtime.resources.maxActiveLocalsPerFunction - active, runtime.resources.maxRegistersPerFunction - active));
+                    },
+                };
+            }));
+            specialization.diagnostics.forEach((diagnostic) => {
+                const module = initialWholeProgram.modules.find((candidate) => candidate.analysis.callGraph.functions.includes(diagnostic.callable));
+                this.diagnosticCollector?.record({
+                    pass: "aggregate-function-specialization",
+                    moduleName: module?.name,
+                    runtimeProfile: this.mode.runtimeProfile,
+                    decision: diagnostic.reason === "variant-created" ? "accepted" : "rejected",
+                    reason: diagnostic.reason,
+                    candidateSize: diagnostic.count,
+                    sourceRange: sourceRangeOf(diagnostic.callable.declaration),
+                });
+            });
+            if (specialization.changed) {
+                this.linkOrder.forEach((moduleName) => {
+                    const ast = this.moduleAST.get(moduleName);
+                    if (!ast)
+                        throw new Error(moduleName + " is not found");
+                    this.moduleResolve.set(moduleName, (0, resolver_1.resolveScopes)(ast));
+                });
+                this.linkedAstGeneration++;
+                this.wholeProgramObjectsValue = undefined;
+                this.wholeProgramFieldsValue = undefined;
+                this.wholeProgramExportsValue = undefined;
+                initialWholeProgram = this.analyzeWholeProgramObjects();
+                const specializedFields = (0, wholeProgramFields_1.analyzeWholeProgramFields)(initialWholeProgram, {
+                    trustAnnotations: this.mode.assumeAnnotations === true,
+                    metadataOf: (moduleName) => this.getSourceMetadata(moduleName),
+                });
+                const downstream = (0, wholeProgramFields_1.applyWholeProgramFieldRewrites)(initialWholeProgram, specializedFields, (moduleName) => this.getSourceMetadata(moduleName), {
+                    replaceReads: this.mode.fieldValuePropagation,
+                    removeInitializers: this.mode.unusedFieldInitializerRemoval,
+                });
+                if (downstream.removedInitializers > 0)
+                    this.diagnosticCollector?.record({
+                        pass: "aggregate-function-specialization",
+                        moduleName: this.entryModule,
+                        runtimeProfile: this.mode.runtimeProfile,
+                        decision: "accepted",
+                        reason: "dead-field-write",
+                        candidateSize: downstream.removedInitializers,
+                    });
+                if (downstream.changed) {
+                    this.linkOrder.forEach((moduleName) => {
+                        const ast = this.moduleAST.get(moduleName);
+                        if (!ast)
+                            throw new Error(moduleName + " is not found");
+                        this.moduleResolve.set(moduleName, (0, resolver_1.resolveScopes)(ast));
+                    });
+                    this.linkedAstGeneration++;
+                    this.wholeProgramObjectsValue = undefined;
+                    this.wholeProgramFieldsValue = undefined;
+                    this.wholeProgramExportsValue = undefined;
+                    initialWholeProgram = this.analyzeWholeProgramObjects();
+                }
+            }
+        }
+        const resolvedMethodDeclarations = new Set([
+            ...initiallyResolvedMethodDeclarations,
+            ...initialWholeProgram.resolvedMethods.map((method) => method.target.declaration),
+        ]);
+        if (this.mode.parameterPruning) {
+            initialWholeProgram = this.pruneWholeProgramParameters(initialWholeProgram, resolvedMethodDeclarations);
+        }
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            const resolved = this.moduleResolve.get(moduleName);
+            if (!ast || !resolved)
+                throw new Error(moduleName + " is not found");
+            const passes = new optimizerPass_1.PassOrchestrator(ast, resolved);
+            const runtimeProfile = this.mode.runtimeProfile;
+            const moduleRange = sourceRangeOf(ast) ??
+                [0, this.moduleSourceText.get(moduleName)?.length ?? 0];
+            const recordAccepted = (pass, count) => {
+                if (count === 0)
+                    return;
+                this.diagnosticCollector?.record({
+                    pass,
+                    moduleName,
+                    runtimeProfile,
+                    decision: "accepted",
+                    reason: "function-rewrite-applied",
+                    candidateSize: count,
+                    sourceRange: moduleRange,
+                });
+            };
+            const initialAnalysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+            const recursive = new Set(initialAnalysis.callGraph.sccs
+                .filter((scc) => scc.recursive)
+                .flatMap((scc) => scc.functions));
+            initialAnalysis.interprocedural.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+                pass: "interprocedural-summary",
+                moduleName,
+                runtimeProfile,
+                decision: diagnostic.reason === "unknown-call-target"
+                    ? "rejected"
+                    : "accepted",
+                reason: diagnostic.reason,
+                candidateSize: 1,
+                sourceRange: diagnostic.sourceRange ?? moduleRange,
+            }));
+            initialAnalysis.callGraph.functions.forEach((callable) => {
+                if (!callable.symbol || !callable.declaration.isLocal)
+                    return;
+                const calls = initialAnalysis.callGraph.calls.filter((call) => call.targets.has(callable)).length;
+                const reason = recursive.has(callable)
+                    ? "recursive-function"
+                    : callable.declaration.parameters.some((parameter) => parameter.type === "VarargLiteral")
+                        ? "vararg-function"
+                        : callable.symbol.references.length > calls
+                            ? "function-escape"
+                            : undefined;
+                if (!reason)
+                    return;
+                this.diagnosticCollector?.record({
+                    pass: "function-rewrite",
+                    moduleName,
+                    runtimeProfile,
+                    decision: "rejected",
+                    reason,
+                    candidateSize: 1,
+                    sourceRange: sourceRangeOf(callable.declaration),
+                });
+            });
+            if (this.mode.functionInlining)
+                passes.run("inline-closed-single-use-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const result = (0, functionRewrites_1.inlineClosedSingleUseFunctions)(analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName));
+                    recordAccepted("inline-closed-single-use-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            if (this.mode.functionInlining)
+                passes.run("inline-literal-argument-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const result = (0, functionRewrites_1.inlineLiteralArgumentFunctions)(analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName));
+                    recordAccepted("inline-literal-argument-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            if (this.mode.functionInlining)
+                passes.run("inline-tail-call-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const localResources = (0, runtimeEnvironment_1.analyzeLocalResourceUsage)(ast);
+                    const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+                    const result = (0, functionRewrites_1.inlineTailCallFunctions)(ast, analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName), {
+                        maxIntroducedLocalsAt: (statement) => {
+                            const active = localResources.activeLocalsBefore(statement);
+                            if (active === undefined)
+                                return 0;
+                            return Math.max(0, Math.min(runtime.resources.maxActiveLocalsPerFunction - active, runtime.resources.maxRegistersPerFunction - active));
+                        },
+                    });
+                    recordAccepted("inline-tail-call-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            if (this.mode.functionInlining)
+                passes.run("inline-closed-statement-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const result = (0, functionRewrites_1.inlineClosedStatementFunctions)(ast, analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName));
+                    recordAccepted("inline-closed-statement-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            if (this.mode.functionInlining)
+                passes.run("inline-bound-statement-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const localResources = (0, runtimeEnvironment_1.analyzeLocalResourceUsage)(ast);
+                    const result = (0, functionRewrites_1.inlineBoundStatementFunctions)(ast, analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName), {
+                        maxIntroducedLocalsAt: (statement) => {
+                            const active = localResources.activeLocalsBefore(statement);
+                            if (active === undefined)
+                                return 0;
+                            return Math.max(0, Math.min((0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile).resources
+                                .maxActiveLocalsPerFunction - active, (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile).resources
+                                .maxRegistersPerFunction - active));
+                        },
+                    });
+                    recordAccepted("inline-bound-statement-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            this.moduleResolve.set(moduleName, passes.resolved);
+            if (passes.astGeneration > 0) {
+                this.linkedAstGeneration += passes.astGeneration;
+                this.wholeProgramObjectsValue = undefined;
+                this.wholeProgramFieldsValue = undefined;
+                this.wholeProgramExportsValue = undefined;
+            }
+            this.progress?.tick();
+        });
+        this.wholeProgramObjectsValue = this.analyzeWholeProgramObjects();
+        this.recordWholeProgramObjectDiagnostics(this.wholeProgramObjectsValue);
+    }
+    pruneWholeProgramParameters(analysis, resolvedMethodDeclarations) {
+        const functionsByModule = new Map(analysis.modules.map((module) => [
+            module.name,
+            new Set(module.analysis.callGraph.functions),
+        ]));
+        const changedModules = new Set();
+        this.linkOrder.forEach((moduleName) => {
+            const functions = functionsByModule.get(moduleName);
+            if (!functions)
+                return;
+            const result = (0, functionRewrites_1.pruneTrailingUnusedParameters)(analysis.callGraph, this.getSourceMetadata(moduleName), (callable) => functions.has(callable) &&
+                (callable.declaration.identifier?.type !== "MemberExpression" ||
+                    callable.declaration.identifier.indexer !== ":" ||
+                    resolvedMethodDeclarations.has(callable.declaration)));
+            if (!result.changed)
+                return;
+            changedModules.add(moduleName);
+            this.diagnosticCollector?.record({
+                pass: "prune-trailing-unused-parameters",
+                moduleName,
+                runtimeProfile: this.mode.runtimeProfile,
+                decision: "accepted",
+                reason: "function-rewrite-applied",
+                candidateSize: result.prunedParameters,
+                sourceRange: sourceRangeOf(this.moduleAST.get(moduleName) ?? {}),
+            });
+            if (result.prunedMethodParameters > 0)
+                this.diagnosticCollector?.record({
+                    pass: "whole-program-method-parameter-pruning",
+                    moduleName,
+                    runtimeProfile: this.mode.runtimeProfile,
+                    decision: "accepted",
+                    reason: "function-rewrite-applied",
+                    candidateSize: result.prunedMethodParameters,
+                    sourceRange: sourceRangeOf(this.moduleAST.get(moduleName) ?? {}),
+                });
+        });
+        if (changedModules.size === 0)
+            return analysis;
+        changedModules.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            if (!ast)
+                throw new Error(moduleName + " is not found");
+            this.moduleResolve.set(moduleName, (0, resolver_1.resolveScopes)(ast));
+        });
+        this.linkedAstGeneration++;
+        this.wholeProgramObjectsValue = undefined;
+        this.wholeProgramFieldsValue = undefined;
+        this.wholeProgramExportsValue = undefined;
+        return this.analyzeWholeProgramObjects();
+    }
+    analyzeWholeProgramObjects() {
+        const modules = this.linkOrder.map((name) => {
+            const chunk = this.moduleAST.get(name);
+            const resolved = this.moduleResolve.get(name);
+            if (!chunk || !resolved)
+                throw new Error(name + " is not found");
+            const module = {
+                name,
+                chunk,
+                resolved,
+                analysis: (0, optimizerAnalysis_1.analyzeOptimizer)(chunk, resolved, {
+                    generation: this.linkedAstGeneration,
+                }),
+            };
+            this.progress?.tick();
+            return module;
+        });
+        return (0, wholeProgramObjects_1.analyzeWholeProgramObjects)(modules, this.linkedAstGeneration);
+    }
+    recordWholeProgramObjectDiagnostics(analysis) {
+        analysis.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+            pass: "whole-program-method-resolution",
+            moduleName: diagnostic.moduleName,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: diagnostic.reason === "resolved-method-target"
+                ? "accepted"
+                : "rejected",
+            reason: diagnostic.reason,
+            candidateSize: 1,
+            sourceRange: diagnostic.sourceRange,
+        }));
+    }
+    requiresSchedulerSelection() {
+        if (this.mode.localDeclarationMerging)
+            return true;
+        const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+        const lifetimeAllowed = !runtime.semantics.debugLocalIntrospection ||
+            this.mode.allowIntrospectionChanges === true;
+        return (lifetimeAllowed &&
+            (this.mode.localDeclarationHoisting || this.mode.tableReadMerging));
+    }
+    functionRewritesEnabled() {
+        const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+        return ((this.mode.parameterPruning ||
+            this.mode.functionInlining ||
+            this.mode.functionSpecialization) &&
+            (!runtime.semantics.debugLocalIntrospection ||
+                this.mode.allowIntrospectionChanges === true));
+    }
+    functionSpecializationEnabled() {
+        if (!this.mode.functionSpecialization)
+            return false;
+        const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+        return (!runtime.semantics.debugLocalIntrospection ||
+            this.mode.allowIntrospectionChanges === true);
+    }
+    fieldFactsEnabled() {
+        return (this.mode.fieldValuePropagation || this.mode.unusedFieldInitializerRemoval);
+    }
+    fieldRenamesEnabled() {
+        return this.mode.fieldRenaming;
+    }
+    exportDceEnabled() {
+        return this.mode.unusedExportRemoval;
+    }
+    copyDiagnosticsFrom(minifier) {
+        minifier.optimizationDiagnostics.forEach((diagnostic) => this.diagnosticCollector?.record(diagnostic));
+    }
+    adoptVariant(minifier, output) {
+        this.identifiersInUse.clear();
+        minifier.identifiersInUse.forEach((name) => this.identifiersInUse.add(name));
+        copyMap(minifier.moduleSourceText, this.moduleSourceText);
+        copyMap(minifier.moduleAST, this.moduleAST);
+        copyMap(minifier.moduleNameAndFileName, this.moduleNameAndFileName);
+        this.linkOrder.splice(0, this.linkOrder.length, ...minifier.linkOrder);
+        copyMap(minifier.moduleResolve, this.moduleResolve);
+        copyMap(minifier.renameCache, this.renameCache);
+        this.globalRenames = new Map(minifier.globalRenames);
+        copyMap(minifier.moduleMetadata, this.moduleMetadata);
+        this.linkedAstGeneration = minifier.linkedAstGeneration;
+        this.wholeProgramObjectsValue = minifier.wholeProgramObjectsValue;
+        this.wholeProgramFieldsValue = minifier.wholeProgramFieldsValue;
+        this.wholeProgramExportsValue = minifier.wholeProgramExportsValue;
+        this.wholeProgramFieldRenamesValue = minifier.wholeProgramFieldRenamesValue;
+        this.exportDceChanged = minifier.exportDceChanged;
+        return output;
+    }
+    recordFinalSchedulerDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "statement-scheduler-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalFunctionRewriteDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "function-rewrite-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalAggregateSpecializationDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "aggregate-specialization-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalFieldFactDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "constructor-field-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalExportDceDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "module-export-dce-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalFieldRenameDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "whole-program-field-rename-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordWholeProgramFieldRenameDiagnostics(plan) {
+        plan.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+            pass: "whole-program-field-rename",
+            moduleName: diagnostic.moduleName,
+            fieldName: diagnostic.field,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: diagnostic.accepted ? "accepted" : "rejected",
+            reason: diagnostic.reason,
+            candidateSize: 1,
+            sourceRange: diagnostic.sourceRange,
+        }));
+    }
     /**
      * dofileの呼び出し箇所ごとに、キャッシュ済みASTから新規にSourceNodeを作り直す。
      * 同じSourceNodeインスタンスを複数箇所へ挿入すると壊れるため、常に作り直す（#18）。
@@ -91,14 +1003,14 @@ class Minifier {
         if (!ast || !fileName) {
             throw new Error(moduleName + " is not found");
         }
-        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parseAsStatementsAndFinalExpression(moduleName === this.entryModule);
+        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parseAsStatementsAndFinalExpression();
     }
     /**
      * 指定モジュールのRenameパス結果を返す。`renameAll`で事前に計算済みの
      * ものをそのまま返すだけの参照用アクセサ。
      */
     getRenameResult(moduleName) {
-        if (this.mode.rename === false) {
+        if (!this.mode.localRenaming && !this.mode.globalRenaming) {
             return NO_RENAME;
         }
         const cached = this.renameCache.get(moduleName);
@@ -107,6 +1019,18 @@ class Minifier {
         }
         return cached;
     }
+    getFieldRename(node) {
+        const name = this.wholeProgramFieldRenamesValue?.nameOf(node);
+        const originalName = this.wholeProgramFieldRenamesValue?.originalNameOf(node);
+        return name && originalName ? { name, originalName } : undefined;
+    }
+    getSourceMetadata(moduleName) {
+        const metadata = this.moduleMetadata.get(moduleName);
+        if (!metadata) {
+            throw new Error(moduleName + " is not found");
+        }
+        return metadata;
+    }
     /**
      * Renameパス（#20）: linkOrder（依存されている側が先）の順にモジュールごとの
      * 短縮名を割り当てる。
@@ -120,17 +1044,25 @@ class Minifier {
      * 犠牲になるが、モジュール内でのスコープに基づく再利用は維持される）。
      */
     renameAll() {
-        if (this.mode.rename === false) {
+        if (!this.mode.localRenaming && !this.mode.globalRenaming) {
             return;
         }
         this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
             const resolved = this.moduleResolve.get(moduleName);
-            if (!resolved) {
+            if (!ast || !resolved) {
                 throw new Error(moduleName + " is not found");
             }
-            const result = (0, renamer_1.assignRenames)(resolved, this.identifiersInUse, this.globalRenames);
+            const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+            const result = this.renameCache.get(moduleName) ??
+                (0, renamer_1.assignRenames)(ast, resolved, this.identifiersInUse, this.globalRenames, new Set(resolved.symbols.filter((symbol) => this.getSourceMetadata(moduleName).annotationsOfIdentifier(symbol.declaration).keepName)), {
+                    allowLocalNameReuse: !runtime.semantics.debugLocalIntrospection ||
+                        this.mode.allowIntrospectionChanges === true,
+                    renameLocals: this.mode.localRenaming,
+                });
             this.renameCache.set(moduleName, result);
             result.usedNames.forEach((name) => this.identifiersInUse.add(name));
+            this.progress?.tick();
         });
     }
     /**
@@ -158,25 +1090,137 @@ class Minifier {
         const excludeGlobalNames = new Set([
             ...this.globalRenames.keys(),
             ...(this.mode.neverRenameGlobals ?? []),
+            ...this.annotationProtectedGlobals(),
         ]);
+        // renameAllと同じmodule順・予約名更新で仮Renameを行い、plannerのbyte costを
+        // 実際の出力名長に対する保守的な見積りにする。
+        const plannedIdentifiersInUse = new Set(this.identifiersInUse);
         this.linkOrder.forEach((moduleName) => {
             const ast = this.moduleAST.get(moduleName);
             let resolved = this.moduleResolve.get(moduleName);
             if (!ast || !resolved) {
                 throw new Error(moduleName + " is not found");
             }
-            if (this.mode.rename !== false && this.mode.globalAlias !== false) {
-                (0, transform_1.insertGlobalAliases)(ast, resolved, {
-                    excludeNames: excludeGlobalNames,
+            const passes = new optimizerPass_1.PassOrchestrator(ast, resolved);
+            if (this.mode.globalAliasing) {
+                passes.run("global-alias", (currentResolve) => {
+                    const changed = (0, transform_1.insertGlobalAliases)(ast, currentResolve, {
+                        excludeNames: excludeGlobalNames,
+                    });
+                    return { changed, invalidatesResolve: changed };
                 });
-                resolved = (0, resolver_1.resolveScopes)(ast);
             }
-            if (this.mode.mergeLocals !== false) {
-                (0, transform_1.mergeLocalDeclarations)(ast, resolved, {
-                    preserveRequireSplice: !this.mode.moduleLikeLua,
+            resolved = passes.resolved;
+            const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+            const optimizerAnalysis = () => passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, (chunk, currentResolve, generation) => (0, optimizerAnalysis_1.analyzeOptimizer)(chunk, currentResolve, {
+                generation,
+                runtime,
+                assumptions: this.mode.allowObservableTableReadChanges === true
+                    ? new Map([
+                        [
+                            "allow-observable-table-read-changes",
+                            "explicit allowObservableTableReadChanges opt-in",
+                        ],
+                    ])
+                    : undefined,
+            }));
+            const localResources = (0, runtimeEnvironment_1.analyzeLocalResourceUsage)(ast);
+            const lifetimeChangesAllowed = !runtime.semantics.debugLocalIntrospection ||
+                this.mode.allowIntrospectionChanges === true;
+            const localNameReuseEnabled = this.mode.localNameReuse && lifetimeChangesAllowed;
+            const keepNames = new Set(resolved.symbols.filter((symbol) => this.getSourceMetadata(moduleName).annotationsOfIdentifier(symbol.declaration).keepName));
+            if (this.schedulerVariant !== "baseline" &&
+                (this.mode.localDeclarationMerging ||
+                    (lifetimeChangesAllowed &&
+                        (this.mode.localDeclarationHoisting || this.mode.tableReadMerging)))) {
+                const provisionalAnalysis = !this.mode.localRenaming && !this.mode.globalRenaming
+                    ? undefined
+                    : optimizerAnalysis();
+                const provisionalRenames = !this.mode.localRenaming && !this.mode.globalRenaming
+                    ? NO_RENAME
+                    : (0, renamer_1.assignRenames)(ast, resolved, plannedIdentifiersInUse, this.globalRenames, keepNames, {
+                        allowLocalNameReuse: localNameReuseEnabled,
+                        renameLocals: this.mode.localRenaming,
+                        analysis: provisionalAnalysis
+                            ? {
+                                facts: provisionalAnalysis.facts,
+                                liveness: provisionalAnalysis.statementDataflow.symbolLiveness,
+                            }
+                            : undefined,
+                    });
+                passes.run("statement-scheduler", (currentResolve) => {
+                    const analysis = optimizerAnalysis();
+                    analysis.interprocedural.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+                        pass: "interprocedural-summary",
+                        moduleName,
+                        runtimeProfile: runtime.profile,
+                        decision: diagnostic.reason === "unknown-call-target"
+                            ? "rejected"
+                            : "accepted",
+                        reason: diagnostic.reason,
+                        candidateSize: 1,
+                        sourceRange: diagnostic.sourceRange,
+                    }));
+                    const metadata = this.getSourceMetadata(moduleName);
+                    const canMoveAnnotatedStatement = (statement) => {
+                        const annotations = metadata.annotationsOf(statement);
+                        return (metadata.beforeOf(statement).length === 0 &&
+                            metadata.trailingOf(statement).length === 0 &&
+                            !annotations.keep &&
+                            !annotations.keepName &&
+                            !annotations.exported);
+                    };
+                    const plan = (0, statementScheduler_1.planStatementSchedule)(ast, currentResolve, {
+                        facts: analysis.facts,
+                        dataflow: analysis.statementDataflow,
+                        outputNameLengthOf: (symbol) => (provisionalRenames.nameOf(symbol.declaration) ?? symbol.name)
+                            .length,
+                        preserveRequireSplice: !this.mode.requireWrapper,
+                        enableLocalPacking: lifetimeChangesAllowed && this.mode.localDeclarationHoisting,
+                        enableLexicalLocalMerge: this.mode.localDeclarationMerging,
+                        tableEffects: lifetimeChangesAllowed && this.mode.tableReadMerging
+                            ? analysis.tableEffects
+                            : undefined,
+                        dirtyGranularity: !this.mode.fieldSensitiveTableEffects
+                            ? "table"
+                            : "static-key",
+                        allowObservableTableValueChanges: this.mode.allowObservableTableReadChanges === true,
+                        maxTableMergeArity: runtime.resources.conservativeParallelValueLimit,
+                        maxTableMergeArityAt: (statement) => (0, runtimeEnvironment_1.checkParallelEvaluation)(runtime, {
+                            activeLocalsBefore: localResources.activeLocalsBefore(statement) ??
+                                runtime.resources.maxActiveLocalsPerFunction,
+                            parallelValueCount: runtime.resources.conservativeParallelValueLimit,
+                        }).limit,
+                        canMoveTableRead: canMoveAnnotatedStatement,
+                        maxHoistedLocalsAt: (statement) => {
+                            const active = localResources.activeLocalsBefore(statement);
+                            if (active === undefined)
+                                return 0;
+                            return Math.max(0, Math.min(runtime.resources.maxActiveLocalsPerFunction - active, runtime.resources.maxRegistersPerFunction - active));
+                        },
+                        canChangeLocalLifetime: canMoveAnnotatedStatement,
+                        diagnostics: this.diagnosticCollector,
+                        moduleName,
+                        runtimeProfile: runtime.profile,
+                    });
+                    return (0, statementScheduler_1.applyStatementSchedule)(plan, this.getSourceMetadata(moduleName));
                 });
             }
+            resolved = passes.resolved;
             this.moduleResolve.set(moduleName, resolved);
+            if (this.mode.localRenaming || this.mode.globalRenaming) {
+                const finalKeepNames = new Set(resolved.symbols.filter((symbol) => this.getSourceMetadata(moduleName).annotationsOfIdentifier(symbol.declaration).keepName));
+                // plannedIdentifiersInUse advances in the same link order as renameAll.
+                // Cache this final-generation result so Print does not rebuild the same
+                // facts, CFG, liveness, graph, and binding proof a second time.
+                const finalRename = (0, renamer_1.assignRenames)(ast, resolved, plannedIdentifiersInUse, this.globalRenames, finalKeepNames, {
+                    allowLocalNameReuse: localNameReuseEnabled,
+                    renameLocals: this.mode.localRenaming,
+                });
+                this.renameCache.set(moduleName, finalRename);
+                finalRename.usedNames.forEach((name) => plannedIdentifiersInUse.add(name));
+            }
+            this.progress?.tick();
         });
     }
     /**
@@ -191,10 +1235,13 @@ class Minifier {
      * ローカルの短縮名がグローバルの新しい短縮名と衝突しうる。
      */
     computeGlobalRenames() {
-        if (this.mode.rename === false || this.mode.globalRename === false) {
+        if (!this.mode.globalRenaming) {
             return;
         }
-        const neverRename = this.mode.neverRenameGlobals ?? new Set();
+        const neverRename = new Set([
+            ...(this.mode.neverRenameGlobals ?? []),
+            ...this.annotationProtectedGlobals(),
+        ]);
         this.globalRenames = (0, globalRename_1.classifyAndRenameGlobals)(this.moduleResolve, neverRename, this.identifiersInUse);
         this.globalRenames.forEach((shortName, originalName) => {
             this.identifiersInUse.add(shortName);
@@ -207,7 +1254,92 @@ class Minifier {
         if (!ast || !fileName) {
             throw new Error(moduleName + " is not found");
         }
-        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parse(moduleName === this.entryModule);
+        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parse();
+    }
+    annotationProtectedGlobals() {
+        const protectedNames = new Set();
+        this.moduleResolve.forEach((resolved, moduleName) => {
+            const metadata = this.getSourceMetadata(moduleName);
+            resolved.globals.forEach((binding) => {
+                if (binding.writes.some((write) => metadata.annotationsOfIdentifier(write).keepName)) {
+                    protectedNames.add(binding.name);
+                }
+            });
+        });
+        return protectedNames;
+    }
+    /**
+     * 定数畳み込みパス（#44）: opt-inオプション。既定では無効。
+     * link()の直後、removeUnusedAll()の前に実行する。伝搬で参照が消えたローカル
+     * 宣言はこのパス自身では消さず、直後に実行される（既定で有効な）未使用ローカル
+     * 削除に任せる。
+     */
+    foldConstantsAll() {
+        if (!this.mode.constantExpressionEvaluation &&
+            !this.mode.localConstantPropagation &&
+            !this.mode.interproceduralConstantPropagation)
+            return;
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            const resolved = this.moduleResolve.get(moduleName);
+            if (!ast || !resolved)
+                throw new Error(moduleName + " is not found");
+            const passes = new optimizerPass_1.PassOrchestrator(ast, resolved);
+            if (this.mode.interproceduralConstantPropagation)
+                passes.run("interprocedural-constants", () => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const changed = (0, interproceduralConstants_1.propagateInterproceduralConstants)(ast, analysis.interprocedural);
+                    return { changed, invalidatesResolve: changed };
+                });
+            if (this.mode.constantExpressionEvaluation ||
+                this.mode.localConstantPropagation)
+                passes.runUntilStable("fold-constants", (currentResolve) => {
+                    const facts = passes.analysis(optimizerFacts_1.OPTIMIZER_FACTS_CACHE_KEY, optimizerFacts_1.analyzeOptimizerFactsAtGeneration);
+                    const changed = (0, constantFold_1.foldConstants)(ast, currentResolve, this.getSourceMetadata(moduleName), facts, {
+                        evaluateExpressions: this.mode.constantExpressionEvaluation,
+                        propagateLocals: this.mode.localConstantPropagation,
+                    });
+                    return { changed, invalidatesResolve: changed };
+                });
+            this.moduleResolve.set(moduleName, passes.resolved);
+            this.progress?.tick();
+        });
+    }
+    removeUnusedAll() {
+        if (!this.mode.unusedLocalRemoval && !this.mode.unusedFunctionRemoval)
+            return;
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            const metadata = this.getSourceMetadata(moduleName);
+            const resolved = this.moduleResolve.get(moduleName);
+            if (!ast || !resolved)
+                throw new Error(moduleName + " is not found");
+            const passes = new optimizerPass_1.PassOrchestrator(ast, resolved);
+            passes.runUntilStable("remove-unused", (currentResolve) => {
+                const facts = passes.analysis(optimizerFacts_1.OPTIMIZER_FACTS_CACHE_KEY, optimizerFacts_1.analyzeOptimizerFactsAtGeneration);
+                const changed = (0, removeUnused_1.removeUnusedLocals)(ast, currentResolve, metadata, facts, (statement) => this.diagnosticCollector?.record({
+                    pass: "function-dce",
+                    moduleName,
+                    runtimeProfile: this.mode.runtimeProfile,
+                    decision: "accepted",
+                    reason: "unused-function",
+                    candidateSize: 1,
+                    sourceRange: sourceRangeOf(statement),
+                }), {
+                    removeLocals: this.mode.unusedLocalRemoval,
+                    removeFunctions: this.mode.unusedFunctionRemoval,
+                });
+                return { changed, invalidatesResolve: changed };
+            });
+            this.moduleResolve.set(moduleName, passes.resolved);
+            this.progress?.tick();
+        });
+    }
+    rebuildIdentifiersInUse() {
+        this.identifiersInUse.clear();
+        this.moduleResolve.forEach((resolved) => {
+            resolved.globals.forEach((binding) => this.identifiersInUse.add(binding.name));
+        });
     }
     /**
      * エントリファイルから到達可能な全モジュールをASTレベルで解決するLinkパス（#18）。
@@ -236,12 +1368,12 @@ class Minifier {
             }
             const code = fs_1.default.readFileSync(fullResolvePath).toString();
             const ast = luaparse_1.default.parse(code, this.luaParseSettings);
+            this.moduleMetadata.set(moduleName, new sourceMetadata_1.SourceMetadata(ast, code));
             // Resolveパス（#19）: このモジュールのスコープ/シンボルを解析し、Renameパスの
             // 入力として使い回せるようキャッシュする。グローバル参照はプログラム全体で
             // 予約すべき名前（identifiersInUse）としてここで集計する。
             const resolved = (0, resolver_1.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ではなく
@@ -253,6 +1385,7 @@ class Minifier {
             visiting.delete(moduleName);
             stack.pop();
             this.linkOrder.push(moduleName);
+            this.progress?.tick();
         };
         visit(this.entryModule);
     }
@@ -275,19 +1408,20 @@ class Minifier {
         });
         return targets;
     }
-    buildRequireWrapper() {
+    printModuleWithRequireWrapper() {
         const targets = this.collectRequireTargets();
-        const parts = [
-            "function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end\n",
+        const moduleNames = this.linkOrder.filter((moduleName) => moduleName !== this.entryModule && targets.has(moduleName));
+        const wrapperAst = (0, generatedAst_1.buildRequireWrapperAst)(moduleNames);
+        const entryAst = this.moduleAST.get(this.entryModule);
+        const entryFileName = this.moduleNameAndFileName.get(this.entryModule);
+        if (!entryAst || !entryFileName) {
+            throw new Error(this.entryModule + " is not found");
+        }
+        const statements = [
+            wrapperAst,
+            { type: "ModuleSplice", moduleName: this.entryModule },
         ];
-        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 source_map_1.SourceNode(null, null, null, parts);
+        return new ast2lua_1.MinifyFile(entryFileName, this.entryModule, entryAst, this, this.mode).printGeneratedStatements(statements);
     }
 }
 exports.Minifier = Minifier;