@zzzen/pyright-internal 1.2.0-dev.20260920 → 1.2.0-dev.20260927

package/dist/analyzer/overloadResultController.js

@@ -0,0 +1,904 @@
+"use strict";
+/*
+ * overloadResultController.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Bounded local overload alternatives and operation control.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExperimentalOverloadResultController = void 0;
+const debug_1 = require("../common/debug");
+const diagnosticSink_1 = require("../common/diagnosticSink");
+const parseNodes_1 = require("../parser/parseNodes");
+const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
+const overloadResultAdmission_1 = require("./overloadResultAdmission");
+const overloadResultSelector_1 = require("./overloadResultSelector");
+const types_1 = require("./types");
+const defaultLimits = {
+    nodes: 4096,
+    records: 256,
+    rootNodes: 256,
+    graphUnits: 32768,
+    candidates: 32,
+    calls: 256,
+    proofUnits: 512,
+};
+class CandidateCutoff extends Error {
+}
+class ActivationRestart extends Error {
+}
+class ExperimentalOverloadResultController {
+    constructor(_options, _evaluator, reader) {
+        this._options = _options;
+        this._evaluator = _evaluator;
+        this.roots = new Map();
+        this._generations = new Map();
+        this._emptyModules = new WeakSet();
+        this._expiredModules = new WeakSet();
+        this._disposed = false;
+        this._activationBoundary = false;
+        this._activationCanRestart = false;
+        this._discovering = false;
+        this._activationChecked = new WeakSet();
+        this._activated = new WeakSet();
+        this._pendingActivation = new Set();
+        this._automaticWork = {
+            modules: 0,
+            nodes: 0,
+            scanCutoffs: 0,
+            seeds: 0,
+            graphAdmitted: 0,
+            selections: 0,
+            selected: 0,
+            proofUnits: 0,
+            activationArgumentChecks: 0,
+            activationProbes: 0,
+            activationProofUnits: 0,
+            activations: 0,
+            reasons: new Map(),
+        };
+        this.installCacheIsolation = (isolation) => {
+            (0, debug_1.assert)(!this._cacheIsolation && !this._disposed);
+            this._cacheIsolation = isolation;
+        };
+        this.installSelector = (select) => {
+            this._select = select;
+        };
+        this.installActivationBoundary = (canActivate, flush) => {
+            this._canActivate = canActivate;
+            this._flushActivation = flush;
+        };
+        this.installQueryCache = (capture) => {
+            this._captureQueryCache = capture;
+        };
+        this.installCheckerHandoff = (handoff) => {
+            this._checkerHandoff = handoff;
+        };
+        this.dispose = () => {
+            for (const generation of this._generations.values()) {
+                this._retire(generation);
+            }
+            this._generations.clear();
+            this._pendingActivation.clear();
+            this._disposed = true;
+        };
+        this.dispatch = (_node, _flags, _context) => undefined;
+        this.route = (request) => {
+            (0, debug_1.assert)(!this._disposed, 'Retired overload-result controller');
+            if (request.kind !== 'statement') {
+                const result = this._query(request.node, request.kind === 'expression' ? request.flags : 0 /* EvalFlags.None */, request.kind === 'expression' ? request.context : undefined, request.kind === 'query');
+                return result ? { result } : undefined;
+            }
+            const generation = this._ensure(request.node);
+            const record = generation?.admission.byNode.get(request.node);
+            if (!generation ||
+                !record ||
+                !this._isEnabled(generation, record) ||
+                record.assignment !== request.node ||
+                this._active?.record === record) {
+                return undefined;
+            }
+            (0, debug_1.assert)(!generation.building.has(record));
+            const outcome = this._build(generation, record);
+            const selected = record.annotated ? outcome.successes[0] : undefined;
+            this._trial(generation, record, selected ? 'materialize-witness' : 'materialize-baseline', outcome.inputs, selected?.candidate, request.evaluate, true);
+            return {};
+        };
+        this.project = (node, result) => {
+            const active = this._active;
+            if (!active) {
+                return result;
+            }
+            if (active.record.seed?.node === node && active.candidate) {
+                result = { ...result, type: active.candidate };
+            }
+            const use = active.inputs.get(node);
+            // Contextual requests use ordinary assignment restoration, not value
+            // substitution that could overwrite a flag-sensitive Name failure.
+            if (use && !active.record.reader && active.mode !== 'context') {
+                const value = use.value.type;
+                result = {
+                    ...result,
+                    type: (0, types_1.isOverloadResult)(value) ? active.candidate ?? value.priv.baselineType : value,
+                };
+                this._emit({ kind: 'project', node, source: value, result, mode: active.mode });
+            }
+            if (active.record.ids.has(node.id)) {
+                active.seen.set(node, result);
+            }
+            return result;
+        };
+        this.beforeCall = (node) => {
+            const active = this._active;
+            if (!active) {
+                return;
+            }
+            this._emit({ kind: 'beforeCall', node, mode: active.mode, seen: active.seen });
+            if (active.mode === 'candidate') {
+                const reservation = active.reservation;
+                if (reservation.used >= reservation.limit) {
+                    throw new CandidateCutoff();
+                }
+                reservation.used++;
+                active.generation.work.candidateCalls++;
+            }
+            else {
+                active.generation.work.ordinaryCalls++;
+            }
+        };
+        this.check = (module) => {
+            const initialGeneration = this._ensure(module);
+            if (!initialGeneration && !this._options.automatic) {
+                return undefined;
+            }
+            initialGeneration?.published.clear();
+            const walk = (node, callback) => {
+                if (node.nodeType === 47 /* ParseNodeType.StatementList */ && this.needsActivationBoundary()) {
+                    return this.runWithActivation(() => walk(node, callback));
+                }
+                const generation = this._ensure(module);
+                const record = generation?.admission.records.get(node);
+                if (this._active || !generation || !record || !this._isEnabled(generation, record)) {
+                    callback();
+                    return;
+                }
+                let handedOff;
+                const canHandoff = this._options.automatic &&
+                    this._options.checkerHandoff === true &&
+                    !this._options.observe &&
+                    !record.assignment &&
+                    !record.seed &&
+                    !record.reader &&
+                    !record.context &&
+                    !record.flags &&
+                    record.root.nodeType === 47 /* ParseNodeType.StatementList */ &&
+                    record.statement === record.expression &&
+                    record.expression.nodeType === 9 /* ParseNodeType.Call */;
+                const output = this._build(generation, record, canHandoff
+                    ? (inputs, candidate, result, diagnostics) => {
+                        if (diagnostics.length || result.typeErrors || result.isIncomplete) {
+                            return;
+                        }
+                        this._checkerHandoff?.(record.root, record.expression, result, () => {
+                            handedOff = this._trial(generation, record, 'check-candidate', inputs, candidate, callback, false, undefined, undefined, true);
+                            generation.work.checkerHandoffs++;
+                        });
+                    }
+                    : undefined);
+                const selected = output.successes[0];
+                const mode = record.reader ? 'reader' : selected ? 'check-candidate' : 'check-baseline';
+                const committed = handedOff ?? this._trial(generation, record, mode, output.inputs, selected?.candidate, callback);
+                (0, debug_1.assert)(!generation.published.has(record));
+                generation.published.add(record);
+                committed.diagnostics.forEach((d) => generation.file.diagnosticSink.addDiagnostic(d));
+                this._emit({ kind: 'publish', root: record.root, diagnostics: committed.diagnostics });
+            };
+            return {
+                walk,
+                dispose: () => { },
+            };
+        };
+        this._limits = { ...defaultLimits, ..._options.limits };
+        (0, debug_1.assert)(!_options.automatic || !_options.seeds, 'Automatic discovery cannot use injected seeds');
+        for (const key of Object.keys(defaultLimits)) {
+            const value = this._limits[key];
+            (0, debug_1.assert)(Number.isInteger(value) && value >= 0 && value <= defaultLimits[key], `Invalid ${key} limit`);
+        }
+        for (const value of [_options.producerCalls, _options.consumerCalls]) {
+            (0, debug_1.assert)(value === undefined || (Number.isInteger(value) && value >= 0 && value <= defaultLimits.calls));
+        }
+        this._info = (0, analyzerNodeInfo_1.createAnalyzerNodeInfoAccessor)(reader);
+    }
+    get isAutomatic() {
+        return !!this._options.automatic;
+    }
+    get hasPendingActivation() {
+        return this._pendingActivation.size > 0;
+    }
+    getAutomaticStats() {
+        return { ...this._automaticWork, reasons: Object.fromEntries(this._automaticWork.reasons) };
+    }
+    getDiagnosticSink(node) {
+        const active = this._active;
+        const record = active?.generation.admission.byNode.get(node);
+        if (!active ||
+            !record ||
+            this._isEnabled(active.generation, record) ||
+            record.fn !== active.record.fn ||
+            record.root.start >= active.record.root.start) {
+            return undefined;
+        }
+        // Earlier ordinary flow prerequisites keep their native caches. Their
+        // diagnostics must likewise outlive this operation's private trial.
+        let outer = active;
+        while (outer.parent?.generation === active.generation) {
+            outer = outer.parent;
+        }
+        return outer.previousSink;
+    }
+    needsActivationBoundary() {
+        return this._options.automatic && !this._activationBoundary && !this._active;
+    }
+    runWithActivation(callback) {
+        (0, debug_1.assert)(!this._disposed, 'Retired overload-result controller');
+        (0, debug_1.assert)(!this._activationBoundary);
+        this._activationBoundary = true;
+        try {
+            this._activationCanRestart = this._canActivate();
+            while (true) {
+                try {
+                    if (this._activationCanRestart && this.hasPendingActivation) {
+                        this._flushActivation();
+                    }
+                    return callback();
+                }
+                catch (error) {
+                    if (!(error instanceof ActivationRestart)) {
+                        throw error;
+                    }
+                }
+            }
+        }
+        finally {
+            this._activationBoundary = false;
+            this._activationCanRestart = false;
+        }
+    }
+    considerActivation(node, args) {
+        if (!this._options.automatic ||
+            (this._active &&
+                (!this._activationCanRestart ||
+                    this._active.parent ||
+                    this._active.mode !== 'baseline' ||
+                    this._active.record.ids.has(node.id))) ||
+            this._discovering ||
+            !this._activationBoundary ||
+            this._activationChecked.has(node) ||
+            !(0, overloadResultSelector_1.isAutomaticOverloadSeedSyntax)(node)) {
+            return;
+        }
+        this._automaticWork.activationArgumentChecks++;
+        if (!args.some((arg) => (0, types_1.isClassInstance)(arg.argType) &&
+            arg.argType.priv.typeArgs?.length &&
+            (0, overloadResultSelector_1.isFixedOverloadArgumentShape)(arg.argType, new overloadResultSelector_1.OverloadSelectionBudget(this._limits.proofUnits)) &&
+            (0, overloadResultSelector_1.hasNestedOverloadAny)(arg.argType))) {
+            return;
+        }
+        this._discovering = true;
+        try {
+            if (!(0, overloadResultSelector_1.findAutomaticOverloadSeeds)([node], this._evaluator()).length) {
+                return;
+            }
+            const selection = this._select(node, this._limits.candidates, this._limits.proofUnits);
+            this._automaticWork.activationProbes++;
+            this._automaticWork.activationProofUnits += selection.units;
+            this._emit({ kind: 'activationProbe', node, selection });
+            if (selection.reason === 'selected') {
+                this._activationChecked.add(node);
+                this._pendingActivation.add(node);
+                // Unwind native speculation before it can publish or cache
+                // further uses of the provisional ordinary result.
+                if (this._activationCanRestart) {
+                    throw new ActivationRestart();
+                }
+            }
+        }
+        finally {
+            this._discovering = false;
+        }
+    }
+    finishActivation() {
+        if (this._active || this._discovering || !this._pendingActivation.size) {
+            return;
+        }
+        let activated = false;
+        this._discovering = true;
+        try {
+            for (const node of this._pendingActivation) {
+                this._activated.add(node);
+                const generation = this._ensure(node, true);
+                const record = generation?.admission.byNode.get(node);
+                if (generation && record?.admitted && record.seed?.node === node) {
+                    this._reserveGeneration(generation);
+                    this._automaticWork.activations++;
+                    activated = true;
+                }
+                else {
+                    this._activated.delete(node);
+                }
+            }
+            this._pendingActivation.clear();
+        }
+        finally {
+            this._discovering = false;
+        }
+        if (activated) {
+            throw new ActivationRestart();
+        }
+    }
+    evict(module) {
+        (0, debug_1.assert)(!this._active);
+        const generation = this._ensure(module);
+        generation?.admission.records.forEach((record) => {
+            if (this._isEnabled(generation, record)) {
+                this._cacheIsolation.evict(record.root);
+            }
+        });
+    }
+    getStats(module) {
+        if (this._disposed) {
+            return undefined;
+        }
+        const generation = this._generations.get(this._info.getFileInfo(module).fileUri.key);
+        if (!generation || generation.module !== module) {
+            return undefined;
+        }
+        return {
+            ...generation.work,
+            records: generation.admission.records.size,
+            outcomes: generation.outcomes.size,
+            variants: [...generation.variants.values()].reduce((n, v) => n + v.size, 0),
+            slots: generation.slots.size,
+            candidateCallCeiling: [...generation.slots.values()].reduce((n, s) => n + s.limit, 0),
+            interruptedSlots: generation.interrupted.size,
+        };
+    }
+    _emit(event) {
+        this._options.observe?.(event);
+    }
+    _retire(generation) {
+        this._emit({ kind: 'retire', module: generation.module, outcomes: generation.outcomes.size });
+        this._expiredModules.add(generation.module);
+        generation.admission.records.forEach((record) => this.roots.delete(record.root));
+        generation.variants.forEach((_, node) => this.roots.delete(node));
+        generation.outcomes.clear();
+        generation.variants.clear();
+        generation.slots.clear();
+        generation.interrupted.clear();
+        generation.ordinaryQueryCaches.clear();
+    }
+    _ensure(node, activate = false) {
+        if (this._options.automatic && !activate && !this._generations.size) {
+            return undefined;
+        }
+        let root = node;
+        while (root.parent) {
+            root = root.parent;
+        }
+        if (root.nodeType !== 36 /* ParseNodeType.Module */ || this._emptyModules.has(root)) {
+            return undefined;
+        }
+        (0, debug_1.assert)(!this._expiredModules.has(root), 'Expired overload-result parse generation');
+        const file = this._info.getFileInfo(root);
+        const old = this._generations.get(file.fileUri.key);
+        if (old?.module === root) {
+            return old;
+        }
+        if (old) {
+            this._retire(old);
+            this._generations.delete(file.fileUri.key);
+        }
+        if (this._options.automatic && !activate) {
+            return undefined;
+        }
+        let seeds = this._options.seeds?.(root) ?? [];
+        if (this._options.automatic) {
+            let nodes = [];
+            let cutoff = false;
+            try {
+                nodes = (0, overloadResultAdmission_1.collectOverloadResultNodes)(root, this._limits.nodes);
+                seeds = (0, overloadResultSelector_1.findAutomaticOverloadSeeds)(nodes, this._evaluator()).map((node) => ({
+                    node,
+                    uncertainty: 2 /* TypeCategory.Any */,
+                    automatic: true,
+                    candidates: () => {
+                        const selection = this._select(node, this._limits.candidates, this._limits.proofUnits);
+                        this._automaticWork.selections++;
+                        this._automaticWork.selected += selection.reason === 'selected' ? 1 : 0;
+                        this._automaticWork.proofUnits += selection.units;
+                        const reasons = this._automaticWork.reasons;
+                        reasons.set(selection.reason, (reasons.get(selection.reason) ?? 0) + 1);
+                        this._emit({ kind: 'selection', node, selection });
+                        return selection.candidates;
+                    },
+                }));
+            }
+            catch (error) {
+                if (!(error instanceof overloadResultAdmission_1.OverloadResultAdmissionLimit)) {
+                    throw error;
+                }
+                cutoff = true;
+            }
+            this._automaticWork.modules++;
+            this._automaticWork.nodes += cutoff ? this._limits.nodes + 1 : nodes.length;
+            this._automaticWork.seeds += seeds.length;
+            this._automaticWork.scanCutoffs += cutoff ? 1 : 0;
+            this._emit({ kind: 'scan', module: root, nodes: nodes.length, seeds: seeds.length, cutoff });
+        }
+        if (!seeds.length) {
+            this._emptyModules.add(root);
+            return undefined;
+        }
+        const admission = (0, overloadResultAdmission_1.admitLocalOverloadResults)(root, seeds, this._evaluator(), this._info, this._limits);
+        if (this._options.automatic) {
+            this._automaticWork.graphAdmitted += [...admission.records.values()].filter((r) => r.seed && r.admitted).length;
+            for (const decision of admission.decisions.values()) {
+                for (const reason of decision) {
+                    const key = `admission:${reason}`;
+                    this._automaticWork.reasons.set(key, (this._automaticWork.reasons.get(key) ?? 0) + 1);
+                }
+            }
+            if (!admission.complete) {
+                const key = `admission:${admission.reason}`;
+                this._automaticWork.reasons.set(key, (this._automaticWork.reasons.get(key) ?? 0) + 1);
+            }
+        }
+        const generation = {
+            module: root,
+            file,
+            admission,
+            outcomes: new Map(),
+            variants: new Map(),
+            slots: new Map(),
+            interrupted: new Set(),
+            building: new Set(),
+            preparing: false,
+            published: new Set(),
+            ordinaryQueryCaches: new Map(),
+            work: {
+                candidateCalls: 0,
+                candidateTrials: 0,
+                ordinaryCalls: 0,
+                ordinaryRequests: 0,
+                projectionSetup: 0,
+                contextualRequests: 0,
+                retryReservations: 0,
+                checkerHandoffs: 0,
+            },
+        };
+        this._emit({ kind: 'admission', module: root, admission });
+        this._generations.set(file.fileUri.key, generation);
+        this._reserveGeneration(generation);
+        return generation;
+    }
+    _isEnabled(generation, record) {
+        return (record.admitted &&
+            (!this._options.automatic ||
+                [...(generation.admission.dependencies.get(record) ?? [])].every((origin) => !!origin.seed && this._activated.has(origin.seed.node))));
+    }
+    _reserveGeneration(generation) {
+        const reserve = (node, flags, seed) => {
+            const key = this._key(node, flags);
+            if (!generation.slots.has(key)) {
+                generation.slots.set(key, {
+                    used: 0,
+                    attempts: 0,
+                    limit: (seed ? this._options.producerCalls : this._options.consumerCalls) ?? this._limits.calls,
+                });
+            }
+        };
+        for (const record of generation.admission.records.values()) {
+            if (!this._isEnabled(generation, record)) {
+                continue;
+            }
+            this.roots.set(record.root, record.ids);
+            reserve(record.root, 0 /* EvalFlags.None */, !!record.seed);
+            for (const value of record.valueNodes) {
+                if ((0, parseNodes_1.isExpressionNode)(value)) {
+                    const seed = record.seed?.node;
+                    const containsSeed = !!seed && seed.start >= value.start && seed.start + seed.length <= value.start + value.length;
+                    reserve(value, 0 /* EvalFlags.None */, containsSeed);
+                    reserve(value, 2 /* EvalFlags.NoSpecialize */, containsSeed);
+                }
+            }
+        }
+    }
+    _key(node, flags = 0 /* EvalFlags.None */) {
+        return `${node.id}:${flags}`;
+    }
+    _definition(generation, node) {
+        return generation.admission.definitions.get(node) ?? generation.admission.reaching.get(node);
+    }
+    _inputs(generation, record) {
+        const uses = [];
+        for (const node of record.nodes) {
+            if (node.nodeType !== 38 /* ParseNodeType.Name */ || node === record.target) {
+                continue;
+            }
+            const producer = this._definition(generation, node);
+            if (!producer || !this._isEnabled(generation, producer) || producer === record) {
+                continue;
+            }
+            const value = this._build(generation, producer).value;
+            if (value) {
+                uses.push({ node, value });
+            }
+        }
+        const alternatives = uses.filter((use) => (0, types_1.isOverloadResult)(use.value.type));
+        (0, debug_1.assert)(alternatives.length <= 1, 'Prepublication admission invariant');
+        return { uses, alternative: alternatives[0] };
+    }
+    _trial(generation, record, mode, inputs, candidate, callback, retain = false, reservation, continuation, liveCheckerCache = false) {
+        const evaluator = this._evaluator();
+        const parent = this._active;
+        const previousSink = generation.file.diagnosticSink;
+        const sink = new diagnosticSink_1.TextRangeDiagnosticSink(generation.file.lines);
+        const nestedSpeculative = !!parent && evaluator.isSpeculativeModeInUse(undefined);
+        (0, debug_1.assert)(!nestedSpeculative || retain);
+        (0, debug_1.assert)(!liveCheckerCache ||
+            (parent?.record === record &&
+                parent.mode === 'candidate' &&
+                mode === 'check-candidate' &&
+                !nestedSpeculative &&
+                !retain &&
+                !reservation));
+        const projections = new Map(inputs.uses.map((use) => [use.node, use]));
+        generation.work.projectionSetup += projections.size;
+        (0, debug_1.assert)(projections.size <= this._limits.rootNodes);
+        const active = {
+            generation,
+            record,
+            parent,
+            previousSink,
+            mode,
+            inputs: projections,
+            candidate,
+            reservation,
+            seen: new Map(),
+        };
+        if (mode === 'candidate') {
+            generation.work.candidateTrials++;
+        }
+        else {
+            generation.work.ordinaryRequests++;
+        }
+        this._active = active;
+        generation.file.diagnosticSink = sink;
+        let result;
+        let diagnostics = [];
+        let completed = false;
+        try {
+            this._emit({ kind: 'enter', module: generation.module, root: record.root, mode });
+            const evaluate = () => {
+                if (callback) {
+                    callback();
+                }
+                else if (record.assignment) {
+                    evaluator.evaluateTypesForStatement(record.assignment);
+                }
+                else {
+                    return evaluator.getTypeOfExpression(record.expression, record.flags ?? 0 /* EvalFlags.None */, record.context);
+                }
+                return evaluator.getTypeOfExpression(record.expression, record.flags ?? 0 /* EvalFlags.None */, record.context);
+            };
+            const evaluateAndContinue = () => {
+                const value = evaluate();
+                if (continuation) {
+                    diagnostics = sink.fetchAndClear();
+                    continuation(value, diagnostics);
+                }
+                return value;
+            };
+            result =
+                nestedSpeculative || liveCheckerCache
+                    ? evaluateAndContinue()
+                    : this._cacheIsolation.isolate(record.root, evaluateAndContinue, retain);
+            completed = true;
+        }
+        finally {
+            diagnostics.push(...sink.fetchAndClear());
+            generation.file.diagnosticSink = previousSink;
+            this._active = parent;
+            this._emit({
+                kind: 'trial',
+                root: record.root,
+                mode,
+                result,
+                diagnostics,
+                failed: !!result?.typeErrors || diagnostics.some((d) => d.category === 0 /* DiagnosticCategory.Error */),
+                retained: retain,
+                nestedSpeculative,
+                exception: !completed,
+            });
+        }
+        return {
+            result,
+            diagnostics,
+            failed: !!result.typeErrors || diagnostics.some((d) => d.category === 0 /* DiagnosticCategory.Error */),
+        };
+    }
+    _build(generation, record, checkerContinuation) {
+        const cached = generation.outcomes.get(record);
+        if (cached) {
+            return cached;
+        }
+        if (!this._active && !generation.building.size && !generation.preparing) {
+            // A cold read can ask code flow about earlier calls that do not
+            // return. Their speculative checks may restore earlier assignments.
+            // Complete those static local records before entering a trial, so
+            // reentry restores owned outcomes rather than discovering new ones
+            // inside somebody else's speculative context.
+            generation.preparing = true;
+            try {
+                for (const prior of generation.admission.records.values()) {
+                    if (this._isEnabled(generation, prior) &&
+                        prior.fn === record.fn &&
+                        prior.root.start < record.root.start) {
+                        this._build(generation, prior);
+                    }
+                }
+            }
+            finally {
+                generation.preparing = false;
+            }
+        }
+        if (!this._active && !generation.building.size) {
+            for (const slot of generation.interrupted) {
+                slot.used = 0;
+                slot.attempts = 0;
+                generation.work.retryReservations++;
+            }
+            generation.interrupted.clear();
+        }
+        const reservation = generation.slots.get(this._key(record.root, record.flags));
+        (0, debug_1.assert)(reservation && !generation.interrupted.has(reservation));
+        (0, debug_1.assert)(!generation.building.has(record));
+        generation.building.add(record);
+        try {
+            const inputs = this._inputs(generation, record);
+            const baseline = this._trial(generation, record, 'baseline', inputs);
+            const alias = !!record.target &&
+                !record.annotated &&
+                record.expression === inputs.alternative?.node &&
+                !baseline.failed;
+            const successes = [];
+            let cutoff = false;
+            if (!alias &&
+                !record.reader &&
+                (!record.target || !baseline.failed || record.annotated) &&
+                !baseline.result.isIncomplete) {
+                const alternative = inputs.alternative?.value.type;
+                try {
+                    let candidates = [];
+                    if (record.seed && !baseline.failed) {
+                        if (record.seed.automatic) {
+                            // Discovery runs inside the same private ordinary cache
+                            // and diagnostic transaction as the complete operation.
+                            const discovery = this._trial(generation, record, 'candidate', inputs, undefined, () => {
+                                candidates = record.seed.candidates(this._evaluator());
+                            }, false, reservation);
+                            if (discovery.failed || discovery.result.isIncomplete) {
+                                candidates = [];
+                            }
+                        }
+                        else {
+                            candidates = record.seed.candidates(this._evaluator());
+                        }
+                    }
+                    else if (alternative && (0, types_1.isOverloadResult)(alternative)) {
+                        candidates = alternative.priv.candidates;
+                    }
+                    if (candidates.length > this._limits.candidates) {
+                        throw new CandidateCutoff();
+                    }
+                    for (const [index, candidate] of candidates.entries()) {
+                        (0, debug_1.assert)(!(0, types_1.isOverloadResult)(candidate), 'Fixed seeds must be ordinary root alternatives');
+                        if (reservation.used >= reservation.limit) {
+                            throw new CandidateCutoff();
+                        }
+                        (0, debug_1.assert)(reservation.attempts < this._limits.candidates);
+                        reservation.attempts++;
+                        const outcome = this._trial(generation, record, 'candidate', inputs, candidate, undefined, false, reservation, checkerContinuation && !successes.length && index === candidates.length - 1
+                            ? (result, diagnostics) => checkerContinuation(inputs, candidate, result, diagnostics)
+                            : undefined);
+                        if (outcome.result.isIncomplete) {
+                            throw new CandidateCutoff();
+                        }
+                        if (!outcome.failed) {
+                            successes.push({ candidate, outcome });
+                        }
+                    }
+                }
+                catch (error) {
+                    if (!(error instanceof CandidateCutoff)) {
+                        throw error;
+                    }
+                    successes.length = 0;
+                    cutoff = true;
+                }
+            }
+            let canonical = baseline.result;
+            if (record.reader) {
+                canonical = this._trial(generation, record, 'reader', inputs).result;
+            }
+            else if (alias) {
+                canonical = inputs.alternative.value;
+            }
+            else if (successes.length) {
+                const source = inputs.alternative?.value.type;
+                const uncertainty = record.seed?.uncertainty ??
+                    (source && (0, types_1.isOverloadResult)(source) ? source.priv.uncertaintyKind : 2 /* TypeCategory.Any */);
+                canonical = {
+                    ...baseline.result,
+                    type: types_1.OverloadResultType.create(successes.map((s) => s.outcome.result.type), baseline.result.type, uncertainty),
+                };
+            }
+            let value;
+            if (record.target) {
+                value =
+                    record.annotated && successes.length
+                        ? successes[0].outcome.result
+                        : !baseline.failed
+                            ? canonical
+                            : undefined;
+            }
+            const outcome = { baseline, canonical, value, inputs, successes };
+            generation.outcomes.set(record, outcome);
+            this._emit({ kind: 'value', root: record.root, canonical, baseline: baseline.result, cutoff });
+            return outcome;
+        }
+        catch (error) {
+            generation.interrupted.add(reservation);
+            throw error;
+        }
+        finally {
+            generation.building.delete(record);
+        }
+    }
+    _variant(generation, record, node, flags) {
+        let variants = generation.variants.get(node);
+        if (!variants) {
+            variants = new Map();
+            generation.variants.set(node, variants);
+        }
+        let variant = variants.get(flags);
+        if (!variant) {
+            variant = this._expressionRecord(record, node, flags);
+            variants.set(flags, variant);
+            this.roots.set(node, variant.ids);
+        }
+        return variant;
+    }
+    _expressionRecord(record, node, flags, context) {
+        const nodes = (0, overloadResultAdmission_1.collectOverloadResultNodes)(node, this._limits.rootNodes);
+        const ordinaryContext = context &&
+            ((0, types_1.isOverloadResult)(context.expectedType) ||
+                (context.returnTypeOverride && (0, types_1.isOverloadResult)(context.returnTypeOverride)))
+            ? {
+                ...context,
+                expectedType: (0, types_1.isOverloadResult)(context.expectedType)
+                    ? context.expectedType.priv.baselineType
+                    : context.expectedType,
+                returnTypeOverride: context.returnTypeOverride && (0, types_1.isOverloadResult)(context.returnTypeOverride)
+                    ? context.returnTypeOverride.priv.baselineType
+                    : context.returnTypeOverride,
+            }
+            : context;
+        return {
+            ...record,
+            root: node,
+            statement: node,
+            expression: node,
+            nodes,
+            ids: new Set(nodes.map((n) => n.id)),
+            assignment: undefined,
+            target: undefined,
+            annotated: false,
+            reader: record.reader && node === record.expression,
+            seed: record.seed && nodes.includes(record.seed.node) ? record.seed : undefined,
+            flags,
+            context: ordinaryContext,
+        };
+    }
+    _queryOutcome(generation, record, queryNode) {
+        const outcome = this._build(generation, record);
+        if (!(0, types_1.isOverloadResult)(outcome.canonical.type) && !outcome.inputs.alternative) {
+            if (queryNode && generation.ordinaryQueryCaches.get(queryNode)?.()) {
+                return outcome.canonical;
+            }
+            // A declined operation still owns its diagnostics. Restore ordinary
+            // subnode caches privately rather than bypassing evaluation or
+            // replaying its diagnostics into a public query's live sink.
+            const result = this._trial(generation, record, 'materialize-baseline', outcome.inputs, undefined, undefined, true).result;
+            if (queryNode) {
+                generation.ordinaryQueryCaches.delete(queryNode);
+                const guard = !result.isIncomplete && this._captureQueryCache?.(record.root, queryNode);
+                if (guard) {
+                    generation.ordinaryQueryCaches.set(queryNode, guard);
+                }
+            }
+            return result;
+        }
+        return outcome.canonical;
+    }
+    _query(node, flags, context, publicQuery = false) {
+        const isCanonicalContext = (flags === 0 /* EvalFlags.None */ || flags === 2 /* EvalFlags.NoSpecialize */) &&
+            (!context || node.nodeType === 38 /* ParseNodeType.Name */);
+        if (this._active) {
+            // Diagnostic readers also evaluate type arguments. Leave their
+            // flag-sensitive validation to the ordinary evaluator in this owner.
+            return this._active.mode === 'reader' && isCanonicalContext
+                ? this._active.inputs.get(node)?.value
+                : undefined;
+        }
+        const generation = this._ensure(node);
+        const record = generation?.admission.byNode.get(node);
+        if (!generation || !record || !this._isEnabled(generation, record) || !record.valueNodes.has(node)) {
+            return undefined;
+        }
+        if (!isCanonicalContext) {
+            // Context-dependent requests are complete ordinary operations, not
+            // canonical memo entries. Their actual flags and context never key a
+            // persistent table or change the context-free published value.
+            const contextual = this._expressionRecord(record, node, flags, context);
+            const prior = this.roots.get(node);
+            this.roots.set(node, contextual.ids);
+            try {
+                generation.work.contextualRequests++;
+                const result = this._trial(generation, contextual, 'context', this._inputs(generation, contextual)).result;
+                this._emit({ kind: 'context', node, flags, context, result });
+                return result;
+            }
+            finally {
+                if (prior) {
+                    this.roots.set(node, prior);
+                }
+                else {
+                    this.roots.delete(node);
+                }
+            }
+        }
+        // Name evaluation does not use an expected type. Its value is the
+        // canonical reaching definition under both supported value flags.
+        if (node.nodeType === 38 /* ParseNodeType.Name */) {
+            if (node.parent?.nodeType === 35 /* ParseNodeType.MemberAccess */ && node.parent.d.member === node) {
+                // A member token represents its enclosing access, not a local.
+                return this._query(node.parent, flags, context);
+            }
+            const definition = this._definition(generation, node);
+            const value = definition && this._isEnabled(generation, definition)
+                ? this._build(generation, definition).value
+                : undefined;
+            if (value && !(0, types_1.isOverloadResult)(value.type)) {
+                // Only public context-free Name readers can reuse a previously
+                // owned restoration. The ordinary reader still returns the
+                // actual cache entry; expression/flag requests always evaluate.
+                this._queryOutcome(generation, record, publicQuery ? node : undefined);
+            }
+            return value && (0, types_1.isOverloadResult)(value.type) ? value : undefined;
+        }
+        if (flags === 0 /* EvalFlags.None */ && (node === record.expression || node === record.statement)) {
+            return this._queryOutcome(generation, record);
+        }
+        if (flags === 2 /* EvalFlags.NoSpecialize */ ||
+            node.nodeType === 9 /* ParseNodeType.Call */ ||
+            node.nodeType === 35 /* ParseNodeType.MemberAccess */ ||
+            node.nodeType === 51 /* ParseNodeType.Ternary */) {
+            return this._queryOutcome(generation, this._variant(generation, record, node, flags));
+        }
+        return undefined;
+    }
+}
+exports.ExperimentalOverloadResultController = ExperimentalOverloadResultController;
+//# sourceMappingURL=overloadResultController.js.map