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

package/dist/analyzer/typeEvaluator.js

@@ -97,6 +97,7 @@ const typeGuards_1 = require("./typeGuards");
 const TypePrinter = __importStar(require("./typePrinter"));
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
+const overloadResultSelector_1 = require("./overloadResultSelector");
 // This table contains the names of several built-in types that
 // are not subscriptable at runtime on older versions of Python.
 // It lists the first version of Python where subscripting is
@@ -192,6 +193,8 @@ const printExpressionTypes = false;
 function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     const nodeInfo = AnalyzerNodeInfo.createAnalyzerNodeInfoAccessor(evaluatorOptions.nodeInfoReader);
     const maxCodeComplexity = evaluatorOptions.maxCodeComplexity;
+    const operationController = evaluatorOptions.experimentalOverloadResult ?? evaluatorOptions.testOnlyExpression;
+    let operationRouter = evaluatorOptions.experimentalOverloadResult?.isAutomatic ? undefined : operationController;
     const symbolResolutionStack = [];
     const speculativeTypeTracker = new typeCacheUtils_1.SpeculativeTypeTracker();
     const suppressedNodeStack = [];
@@ -262,6 +265,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // circular references in complex data structures, so it fails
     // to clean up the objects if we don't help it out.
     function disposeEvaluator() {
+        operationController?.dispose?.();
         functionRecursionMap = new Map();
         codeFlowAnalyzerCache = new Map();
         typeCache = new Map();
@@ -466,10 +470,40 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
+    function finishOverloadActivation() {
+        if (!returnTypeInferenceTypeCache && !isSpeculativeModeInUse(undefined)) {
+            try {
+                evaluatorOptions.experimentalOverloadResult.finishActivation();
+            }
+            finally {
+                // Install routing before an activation restart re-enters evaluation.
+                if (evaluatorOptions.experimentalOverloadResult.roots.size) {
+                    operationRouter = operationController;
+                }
+            }
+        }
+    }
+    function runWithOverloadActivation(callback) {
+        return evaluatorOptions.experimentalOverloadResult.runWithActivation(() => {
+            const result = callback();
+            if (evaluatorOptions.experimentalOverloadResult.hasPendingActivation) {
+                finishOverloadActivation();
+            }
+            return result;
+        });
+    }
     // Determines the type of the specified node by evaluating it in
     // context, logging any errors in the process. This may require the
     // type of surrounding statements to be evaluated.
     function getType(node) {
+        if (evaluatorOptions.experimentalOverloadResult?.needsActivationBoundary()) {
+            return runWithOverloadActivation(() => getType(node));
+        }
+        const canonical = operationRouter?.route?.({ kind: 'query', node })?.result ??
+            evaluatorOptions.testOnlyExpression?.query?.(node);
+        if (canonical) {
+            return canonical.type;
+        }
         initializePrefetchedTypes(node);
         let type = evaluateContextualTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
@@ -508,6 +542,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return type;
     }
     function getTypeResult(node) {
+        if (evaluatorOptions.experimentalOverloadResult?.needsActivationBoundary()) {
+            return runWithOverloadActivation(() => getTypeResult(node));
+        }
+        const canonical = operationRouter?.route?.({ kind: 'query', node })?.result ??
+            evaluatorOptions.testOnlyExpression?.query?.(node);
+        if (canonical) {
+            return canonical;
+        }
         return evaluateContextualTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
         });
@@ -643,6 +685,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function getTypeOfExpression(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
+        if (evaluatorOptions.experimentalOverloadResult?.needsActivationBoundary()) {
+            return runWithOverloadActivation(() => getTypeOfExpression(node, flags, inferenceContext));
+        }
         let useTypeFormCache = (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0;
         if (inferenceContext) {
             inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
@@ -654,6 +699,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 && (flags & 33554432 /* EvalFlags.NoConvertSpecialForm */) === 0) {
             flags |= 32 /* EvalFlags.NoParamSpec */ | 64 /* EvalFlags.NoTypeVarTuple */;
         }
+        const testResult = operationRouter?.route?.({
+            kind: 'expression',
+            node,
+            flags,
+            context: inferenceContext,
+        })?.result ?? operationRouter?.dispatch(node, flags, inferenceContext);
+        if (testResult) {
+            return testResult;
+        }
         // Is this type already cached?
         const cacheEntry = useTypeFormCache
             ? readTypeFormTypeCacheEntry(node, inferenceContext?.expectedType)
@@ -693,6 +747,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // at that point.
         initializePrefetchedTypes(node);
         let typeResult = getTypeOfExpressionCore(node, flags, inferenceContext);
+        if (evaluatorOptions.experimentalOverloadResult?.hasPendingActivation) {
+            finishOverloadActivation();
+        }
+        if (operationRouter) {
+            typeResult = operationRouter.project(node, typeResult);
+        }
         // Should we disable type promotions for bytes?
         if ((0, types_1.isInstantiableClass)(typeResult.type) &&
             typeResult.type.priv.includePromotions &&
@@ -1342,6 +1402,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         recursionCount++;
         switch (type.category) {
+            case 10 /* TypeCategory.OverloadResult */:
+                return true;
             case 0 /* TypeCategory.Unbound */:
             case 1 /* TypeCategory.Unknown */:
             case 2 /* TypeCategory.Any */:
@@ -1440,6 +1502,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         recursionCount++;
         switch (type.category) {
+            case 10 /* TypeCategory.OverloadResult */:
+                return true;
             case 1 /* TypeCategory.Unknown */:
             case 4 /* TypeCategory.Function */:
             case 5 /* TypeCategory.Overloaded */:
@@ -2427,6 +2491,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
+    function getFunctionClassType(type) {
+        const classType = (0, types_1.isMethodType)(type) ? prefetched?.methodClass : prefetched?.functionClass;
+        return classType && (0, types_1.isInstantiableClass)(classType) ? classType : undefined;
+    }
     function getTypingType(node, symbolName) {
         return (getTypeOfModule(node, symbolName, ['typing']) ?? getTypeOfModule(node, symbolName, ['typing_extensions']));
     }
@@ -2571,7 +2639,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if (isNodeReachable(node)) {
             const fileInfo = nodeInfo.getFileInfo(node);
-            return fileInfo.diagnosticSink.addDiagnosticWithTextRange(diagLevel, message, range ?? node);
+            const sink = evaluatorOptions.experimentalOverloadResult?.getDiagnosticSink(node) ?? fileInfo.diagnosticSink;
+            return sink.addDiagnosticWithTextRange(diagLevel, message, range ?? node);
         }
         return undefined;
     }
@@ -3528,7 +3597,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else {
             // Handle the special case of "reveal_type" and "reveal_locals".
-            if (name === 'reveal_type' || name === 'reveal_locals') {
+            if (ParseTreeUtils.isImplicitRevealTypeName(node) || name === 'reveal_locals') {
                 type = types_1.AnyType.create();
             }
             else {
@@ -4432,6 +4501,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 break;
             }
+            case 10 /* TypeCategory.OverloadResult */:
+                throw new Error('Overload-result member dispatch is not enabled');
             default:
                 (0, debug_1.assertNever)(baseType);
         }
@@ -6279,6 +6350,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else {
             baseTypeResult = getTypeOfExpression(node.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */ | (flags & 4 /* EvalFlags.ForwardRefs */));
         }
+        operationRouter?.beforeCall(node);
         const argList = ParseTreeUtils.getArgsByRuntimeOrder(node).map((arg) => {
             const functionArg = {
                 valueExpression: arg.d.valueExpr,
@@ -6296,8 +6368,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeResult = getTypeOfSuperCall(node);
             }
             else if ((0, types_1.isAnyOrUnknown)(baseTypeResult.type) &&
-                node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
-                node.d.leftExpr.d.value === 'reveal_type') {
+                ParseTreeUtils.isImplicitRevealTypeName(node.d.leftExpr)) {
                 // Handle the implicit "reveal_type" call.
                 typeResult = getTypeOfRevealType(node, inferenceContext);
             }
@@ -7058,6 +7129,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     isTypeIncomplete = true;
                 }
                 if (!callResult.argumentErrors && callResult.returnType) {
+                    if (evaluatorOptions.experimentalOverloadResult &&
+                        !callResult.isTypeIncomplete &&
+                        !overload.priv.boundToType &&
+                        !overload.shared.methodClass &&
+                        !overload.shared.declaration?.isMethod &&
+                        errorNode.nodeType === 9 /* ParseNodeType.Call */ &&
+                        errorNode.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                        errorNode.parent?.nodeType === 3 /* ParseNodeType.Assignment */ &&
+                        errorNode.parent.d.rightExpr === errorNode &&
+                        expandedArgTypes.length === 1 &&
+                        !hasArgTypeOverride &&
+                        callResult.argResults) {
+                        evaluatorOptions.experimentalOverloadResult.considerActivation(errorNode, callResult.argResults);
+                    }
                     overloadsUsedForCall.push(overload);
                     matchedOverload = overload;
                     const matchedOverloadInfo = {
@@ -7276,6 +7361,115 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         return winningOverloadIndex === undefined ? undefined : matches[winningOverloadIndex].overload;
     }
+    function selectAutomaticOverloadResult(node, limit, proofUnits) {
+        const budget = new overloadResultSelector_1.OverloadSelectionBudget(proofUnits);
+        const coverage = [];
+        const matches = [];
+        const decline = (reason) => ({
+            candidates: [],
+            reason: budget.exceeded ? 'proof-limit' : reason,
+            coverage,
+            matches,
+            units: budget.used,
+        });
+        return useSpeculativeMode(node, () => {
+            const callee = getTypeOfExpression(node.d.leftExpr, 2 /* EvalFlags.NoSpecialize */);
+            if (callee.isIncomplete || callee.typeErrors || !(0, types_1.isOverloaded)(callee.type)) {
+                return decline('not-complete-overloaded-function');
+            }
+            const overloads = types_1.OverloadedType.getOverloads(callee.type);
+            if (overloads.length > limit) {
+                return decline('candidate-limit');
+            }
+            const args = node.d.args.map((arg) => ({
+                argCategory: arg.d.argCategory,
+                valueExpression: arg.d.valueExpr,
+                node: arg,
+                name: arg.d.name,
+            }));
+            const sources = node.d.args.map((arg) => getTypeOfExpression(arg.d.valueExpr));
+            if (sources.some((s) => s.isIncomplete || s.typeErrors || (0, types_1.isAny)(s.type) || !(0, overloadResultSelector_1.isFixedOverloadArgumentShape)(s.type, budget))) {
+                return decline('unsupported-argument-shape');
+            }
+            if (!sources.some((s) => (0, overloadResultSelector_1.hasNestedOverloadAny)(s.type))) {
+                return decline('no-invariant-any');
+            }
+            const returns = [];
+            for (let index = 0; index < overloads.length; index++) {
+                checkForCancellation();
+                const overload = overloads[index];
+                const declaration = overload.shared.declaration;
+                const declaredReturnType = overload.shared.declaredReturnType;
+                const returnType = types_1.FunctionType.getEffectiveReturnType(overload);
+                if (!declaration ||
+                    declaration.isMethod ||
+                    overload.shared.methodClass ||
+                    overload.priv.boundToType ||
+                    overload.shared.typeParams.length ||
+                    !declaredReturnType ||
+                    !returnType ||
+                    declaration.node.d.decorators.length !== 1 ||
+                    overload.shared.parameters.some((p, i) => p.category !== 0 /* ParamCategory.Simple */ ||
+                        !p.name ||
+                        p.defaultExpr ||
+                        types_1.FunctionType.getParamDefaultType(overload, i))) {
+                    return decline('unsupported-signature');
+                }
+                if (!(0, overloadResultSelector_1.isFixedOverloadReturnShape)(declaredReturnType, budget) ||
+                    (returnType !== declaredReturnType && !(0, overloadResultSelector_1.isFixedOverloadReturnShape)(returnType, budget))) {
+                    return decline('unsupported-return-shape');
+                }
+                const mapping = matchArgsToParams(node, args, { type: overload, isIncomplete: false }, index);
+                if (mapping.isTypeIncomplete) {
+                    return decline('incomplete-mapping');
+                }
+                if (mapping.argumentErrors) {
+                    continue;
+                }
+                if (mapping.argParams.length !== args.length ||
+                    mapping.argParams.some((p, i) => p.argument !== args[i] ||
+                        p.isDefaultArg ||
+                        p.requiresTypeVarMatching ||
+                        !(0, overloadResultSelector_1.isFixedOverloadArgumentShape)(p.paramType, budget))) {
+                    return decline('unsupported-mapping');
+                }
+                // This is the ordinary matcher and solver, not a parallel
+                // assignability algorithm. Only complete successful matches count.
+                const matched = useSpeculativeMode(node, () => validateArgTypesWithContext(node, mapping, new constraintTracker_1.ConstraintTracker(), true, undefined));
+                if (matched.isTypeIncomplete || !matched.returnType) {
+                    return decline('incomplete-solution');
+                }
+                if (!(0, overloadResultSelector_1.isFixedOverloadReturnShape)(matched.returnType, budget)) {
+                    return decline('unsupported-solved-return-shape');
+                }
+                if (matched.argumentErrors) {
+                    continue;
+                }
+                const proof = mapping.argParams.map((p, i) => (0, overloadResultSelector_1.getFixedOverloadCoverage)(sources[i].type, p.paramType, budget));
+                const covered = proof.includes('unsupported')
+                    ? 'unsupported'
+                    : proof.includes('not-covered')
+                        ? 'not-covered'
+                        : 'covered';
+                coverage.push(covered);
+                matches.push(index);
+                if (covered === 'unsupported') {
+                    return decline('unsupported-coverage');
+                }
+                if (!returns.some((type) => (0, types_1.isTypeSame)(type, matched.returnType))) {
+                    returns.push(matched.returnType);
+                }
+                // A covering overload ends the retained prefix; earlier
+                // non-covering matches remain live alternatives.
+                if (covered === 'covered') {
+                    break;
+                }
+            }
+            return returns.length > 1
+                ? { candidates: returns, reason: 'selected', coverage, matches, units: budget.used }
+                : decline('equivalent-or-single-return');
+        });
+    }
     function validateOverloadedArgTypes(errorNode, argList, typeResult, constraints, skipUnknownArgCheck, inferenceContext) {
         const filteredMatchResults = [];
         let contextFreeArgTypes;
@@ -12151,8 +12345,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Validate that we received at least two type arguments. One type argument
         // is allowed if it's an unpacked TypeVarTuple or tuple. None is also allowed
-        // since it is used to define NoReturn in typeshed stubs).
-        if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
+        // since it is used to define NoReturn in typeshed stubs). No type arguments,
+        // as in "Union[()]", is a runtime error.
+        if (types.length === 0 || (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0]))) {
             if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
             }
@@ -12505,6 +12700,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function evaluateTypesForAssignmentStatement(node) {
+        if (operationRouter?.route?.({
+            kind: 'statement',
+            node,
+            evaluate: () => evaluateTypesForAssignmentStatement(node),
+        })) {
+            return;
+        }
         const fileInfo = nodeInfo.getFileInfo(node);
         // If the entire statement has already been evaluated, don't
         // re-evaluate it.
@@ -14643,7 +14845,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return exceptionType;
             }
             if ((0, types_1.isInstantiableClass)(exceptionType)) {
-                if (types_1.ClassType.isBuiltIn(exceptionType, 'BaseException')) {
+                if ((0, typeUtils_1.derivesFromStdlibClass)(exceptionType, 'BaseException') &&
+                    !(0, typeUtils_1.derivesFromStdlibClass)(exceptionType, 'Exception')) {
                     includesBaseException = true;
                 }
                 return types_1.ClassType.cloneAsInstance(exceptionType);
@@ -15365,6 +15568,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // be evaluated to provide sufficient context for the type. Evaluated types
     // are written back to the type cache for later retrieval.
     function evaluateTypesForStatement(node) {
+        if (evaluatorOptions.experimentalOverloadResult?.needsActivationBoundary()) {
+            return runWithOverloadActivation(() => evaluateTypesForStatement(node));
+        }
         initializePrefetchedTypes(node);
         let curNode = node;
         while (curNode) {
@@ -16179,8 +16385,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // PEP 563 indicates that if a forward reference can be resolved in the module
         // scope (or, by implication, in the builtins scope), it should prefer that
-        // resolution over local resolutions.
-        if (symbolWithScope && preferGlobalScope) {
+        // resolution over local resolutions. This doesn't apply to a PEP 695 "type"
+        // statement's target, which binds synchronously in the scope where it appears
+        // (including a class scope) rather than being deferred like other annotations.
+        const isTypeAliasStatementTarget = symbolWithScope?.symbol
+            .getDeclarations()
+            .some((decl) => decl.type === 4 /* DeclarationType.TypeAlias */);
+        if (symbolWithScope && preferGlobalScope && !isTypeAliasStatementTarget) {
             let curSymbolWithScope = symbolWithScope;
             while (curSymbolWithScope.scope.type !== 4 /* ScopeType.Module */ &&
                 curSymbolWithScope.scope.type !== 5 /* ScopeType.Builtin */ &&
@@ -19317,6 +19528,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             /* diag */ undefined, 
             /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount));
     }
+    // Types like "bytes", "bytearray" and "memoryview" support cross-type
+    // content comparisons via "==" and "!=", even though they're otherwise
+    // unrelated (non-overlapping) types. Use derivesFromStdlibClass to check
+    // membership in this group across the MRO.
+    function isBytesLikeType(type) {
+        return ((0, typeUtils_1.derivesFromStdlibClass)(type, 'bytes') ||
+            (0, typeUtils_1.derivesFromStdlibClass)(type, 'bytearray') ||
+            (0, typeUtils_1.derivesFromStdlibClass)(type, 'memoryview'));
+    }
+    // Determines whether the two types are both members of the "bytes-like"
+    // group of types ("bytes", "bytearray" and "memoryview"). Pyright models
+    // this relationship as a "type promotion" (used elsewhere for
+    // assignability), but that grouping is also useful for determining
+    // whether two otherwise-disjoint built-in types can be compared with
+    // "==" or "!=", since these types share compatible "__eq__" semantics
+    // regardless of whether the "disableBytesTypePromotions" setting allows
+    // the assignment.
+    function isTypePromotionRelated(leftType, rightType) {
+        return isBytesLikeType(leftType) && isBytesLikeType(rightType);
+    }
     // Determines whether the two types are potentially comparable -- i.e.
     // their types overlap in such a way that it makes sense for them to
     // be compared with an == or != operator. The functional also supports
@@ -19407,6 +19638,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                         return boolVal === (intVal === 1);
                     }
+                    // Distinct bytes-like classes support cross-type equality regardless
+                    // of disableBytesTypePromotions. Don't apply this to the same class:
+                    // different bytes literals must remain disjoint.
+                    if (!assumeIsOperator &&
+                        !types_1.ClassType.isSameGenericClass(leftType, rightType) &&
+                        isTypePromotionRelated(leftType, rightType)) {
+                        return true;
+                    }
                     return false;
                 }
             }
@@ -19897,8 +20136,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             destParamDetails.firstPositionOrKeywordIndex < srcParamDetails.positionOnlyParamCount &&
             !targetIncludesParamSpec) {
             diag?.createAddendum().addMessage(localize_1.LocAddendum.argsPositionOnly().format({
-                expected: srcParamDetails.positionOnlyParamCount,
-                received: destParamDetails.firstPositionOrKeywordIndex,
+                expected: destParamDetails.firstPositionOrKeywordIndex,
+                received: srcParamDetails.positionOnlyParamCount,
             }));
             canAssign = false;
         }
@@ -21396,6 +21635,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getNoneType,
         getUnionClassType,
         getTypeClassType,
+        getFunctionClassType,
         getBuiltInObject,
         getTypingType,
         getTypeCheckerInternalsType,
@@ -21424,6 +21664,106 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         printControlFlowGraph,
     };
     const codeFlowEngine = (0, codeFlowEngine_1.getCodeFlowEngine)(evaluatorInterface, speculativeTypeTracker, nodeInfo);
+    if (evaluatorOptions.testOnlyMemberAccess) {
+        const { nodes, install } = evaluatorOptions.testOnlyMemberAccess;
+        install((node, baseTypeResult) => {
+            (0, debug_1.assert)(nodes.has(node));
+            return getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'get' }, 2 /* EvalFlags.NoSpecialize */);
+        });
+    }
+    evaluatorOptions.experimentalOverloadResult?.installSelector(selectAutomaticOverloadResult);
+    evaluatorOptions.experimentalOverloadResult?.installActivationBoundary(() => !returnTypeInferenceTypeCache && !isSpeculativeModeInUse(undefined), finishOverloadActivation);
+    evaluatorOptions.experimentalOverloadResult?.installCheckerHandoff((root, expression, result, callback) => {
+        const ids = evaluatorOptions.experimentalOverloadResult.roots.get(root);
+        const isComplete = (value) => !value.isIncomplete &&
+            !value.typeErrors &&
+            !((0, types_1.isFunction)(value.type) && types_1.FunctionType.isPartiallyEvaluated(value.type)) &&
+            !((0, types_1.isClass)(value.type) && types_1.ClassType.isPartiallyEvaluated(value.type));
+        if (!ids ||
+            returnTypeInferenceTypeCache ||
+            isSpeculativeModeInUse(undefined) ||
+            typeCache.get(expression.id)?.typeResult !== result ||
+            typeCache.get(expression.id)?.flags !== 0 /* EvalFlags.None */ ||
+            !isComplete(result)) {
+            return false;
+        }
+        for (const id of ids) {
+            const entry = typeCache.get(id);
+            if ((entry && !isComplete(entry.typeResult)) || typeFormTypeCache.has(id)) {
+                return false;
+            }
+        }
+        // Continue synchronously before this candidate's isolation unwinds. No
+        // saved cache set or result is restored, and the checker reads live entries.
+        checkForCancellation();
+        callback();
+        return true;
+    });
+    evaluatorOptions.experimentalOverloadResult?.installQueryCache((root, node) => {
+        const roots = evaluatorOptions.experimentalOverloadResult.roots;
+        const ids = roots.get(root);
+        const isOrdinaryContext = () => !returnTypeInferenceTypeCache && !isSpeculativeModeInUse(undefined);
+        if (!ids || !isOrdinaryContext()) {
+            return undefined;
+        }
+        const isComplete = (result) => !result.isIncomplete &&
+            !((0, types_1.isFunction)(result.type) && types_1.FunctionType.isPartiallyEvaluated(result.type)) &&
+            !((0, types_1.isClass)(result.type) && types_1.ClassType.isPartiallyEvaluated(result.type));
+        const queryEntry = readContextualTypeCacheEntryForNode(node);
+        if (!queryEntry || !isComplete(queryEntry.typeResult)) {
+            return undefined;
+        }
+        const entries = [...ids].map((id) => ({
+            id,
+            runtime: typeCache.get(id),
+            expected: expectedTypeCache.get(id),
+            typeForm: typeFormTypeCache.get(id),
+        }));
+        const areComplete = () => entries.every((entry) => (!entry.runtime || isComplete(entry.runtime.typeResult)) &&
+            (!entry.typeForm || entry.typeForm.every((e) => isComplete(e.typeResult))));
+        if (!areComplete()) {
+            return undefined;
+        }
+        // This is a validity guard, not a saved public answer. Reuse only while
+        // the complete, privately restored cache set is still installed.
+        return () => {
+            const valid = isOrdinaryContext() &&
+                roots.get(root) === ids &&
+                readContextualTypeCacheEntryForNode(node) === queryEntry &&
+                areComplete() &&
+                entries.every((entry) => typeCache.get(entry.id) === entry.runtime &&
+                    expectedTypeCache.get(entry.id) === entry.expected &&
+                    typeFormTypeCache.get(entry.id) === entry.typeForm);
+            if (valid) {
+                checkForCancellation();
+            }
+            return valid;
+        };
+    });
+    if (operationController) {
+        const { roots } = operationController;
+        operationController.installCacheIsolation({
+            evict(root) {
+                const ids = roots.get(root);
+                (0, debug_1.assert)(ids && ids.size <= 256);
+                (0, debug_1.assert)(!returnTypeInferenceTypeCache && !isSpeculativeModeInUse(undefined));
+                ids.forEach((id) => {
+                    typeCache.delete(id);
+                    expectedTypeCache.delete(id);
+                    typeFormTypeCache.delete(id);
+                });
+                speculativeTypeTracker.evictCacheEntries(ids);
+            },
+            isolate(root, callback, retain = false) {
+                const ids = roots.get(root);
+                (0, debug_1.assert)(ids && ids.size <= 256);
+                // Native argument speculation can query earlier, disjoint operations
+                // through code flow. Never isolate a root that overlaps that context.
+                (0, debug_1.assert)(!returnTypeInferenceTypeCache && speculativeTypeTracker.canUseNodeCacheIsolation(root));
+                return (0, typeCacheUtils_1.useNodeCacheIsolation)(typeCache, ids, () => (0, typeCacheUtils_1.useNodeCacheIsolation)(expectedTypeCache, ids, () => (0, typeCacheUtils_1.useNodeCacheIsolation)(typeFormTypeCache, ids, () => speculativeTypeTracker.useNodeCacheIsolation(ids, callback, root), retain), retain), retain);
+            },
+        });
+    }
     return evaluatorInterface;
 }
 //# sourceMappingURL=typeEvaluator.js.map