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

package/dist/analyzer/typeEvaluator.js

@@ -95,8 +95,10 @@ const typedDicts_1 = require("./typedDicts");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const typeGuards_1 = require("./typeGuards");
 const TypePrinter = __importStar(require("./typePrinter"));
+const typeWalker_1 = require("./typeWalker");
 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 +194,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 +266,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 +471,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 +543,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 +686,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 +700,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 +748,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 +1403,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 +1503,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 */:
@@ -1771,11 +1836,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const argList = [];
         let previousCategory = 0 /* ArgCategory.Simple */;
+        let hasFakeArg = false;
         // Empty arguments do not enter the AST as nodes, but instead are left blank.
         // Instead, we detect when we appear to be between two known arguments or at the
         // end of the argument list and insert a fake argument of an unknown type to have
         // something to match later.
         function addFakeArg() {
+            hasFakeArg = true;
             argList.push({
                 argCategory: previousCategory,
                 typeResult: { type: types_1.UnknownType.create() },
@@ -1812,7 +1879,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* skipUnknownArgCheck */ true, 
                 /* inferenceContext */ undefined);
             });
-            const specializedType = solveAndApplyConstraints(type, constraints);
+            let specializedType = type;
+            if (types_1.FunctionType.getParamSpecFromArgsKwargs(type)) {
+                const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints);
+                // The fake argument is used only to identify the active parameter. Preserve
+                // type variables in that parameter while specializing the forwarded ParamSpec.
+                if (hasFakeArg && callResult?.activeParam) {
+                    const activeParamIndex = type.shared.parameters.indexOf(callResult.activeParam);
+                    if (activeParamIndex >= 0) {
+                        (0, typeUtils_1.getTypeVarArgsRecursive)(types_1.FunctionType.getParamType(type, activeParamIndex)).forEach((typeVar) => {
+                            if (!(0, types_1.isParamSpec)(typeVar)) {
+                                solution.doForEachSolutionSet((solutionSet) => {
+                                    const solvedType = solutionSet.getType(typeVar);
+                                    if (!solvedType || (0, types_1.isUnknown)(solvedType)) {
+                                        solutionSet.setType(typeVar, typeVar);
+                                    }
+                                });
+                            }
+                        });
+                    }
+                }
+                specializedType = (0, typeUtils_1.applySolvedTypeVars)(type, solution);
+            }
             const finalType = (0, types_1.isFunction)(specializedType) ? specializedType : type;
             const hasActiveArg = argList.some((arg) => arg.active);
             // If the type was specialized (e.g. ParamSpec expansion), the activeParam
@@ -2427,6 +2515,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 +2663,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;
     }
@@ -2656,6 +2749,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const memberInfo = (0, typeUtils_1.lookUpClassMember)(classType.classType, nameNode.d.value, 1 /* MemberAccessFlags.SkipOriginalClass */);
                     if (memberInfo?.isTypeDeclared) {
                         declaredType = getTypeOfMember(memberInfo);
+                        if ((0, symbolNameUtils_1.isMethodExemptFromLsp)(nameValue) &&
+                            memberInfo.symbol
+                                .getTypedDeclarations()
+                                .some((decl) => decl.type === 5 /* DeclarationType.Function */) &&
+                            (0, types_1.isFunctionOrOverloaded)(typeResult.type) &&
+                            (0, types_1.isFunctionOrOverloaded)(declaredType) &&
+                            !isFinalVariable(memberInfo.symbol)) {
+                            const baseMethods = (0, types_1.isFunction)(declaredType)
+                                ? [declaredType]
+                                : [
+                                    ...types_1.OverloadedType.getOverloads(declaredType),
+                                    types_1.OverloadedType.getImplementation(declaredType),
+                                ];
+                            if (!baseMethods.some((method) => method && (0, types_1.isFunction)(method) && types_1.FunctionType.isFinal(method))) {
+                                // Apply the same override exemptions to aliases and method definitions.
+                                declaredType = undefined;
+                            }
+                        }
                     }
                 }
             }
@@ -3528,7 +3639,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 +4543,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);
         }
@@ -4499,6 +4612,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isAccessedThroughObject = types_1.TypeBase.isInstance(classType);
         // Always look for a member with a declared type first.
         let memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+        // A class-level method alias retains its inferred signature, unlike an annotated variable.
+        if (usage.method === 'get' &&
+            memberInfo?.skippedUndeclaredType &&
+            memberInfo.symbol.getTypedDeclarations().some((decl) => decl.type === 5 /* DeclarationType.Function */)) {
+            const inferredMember = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags);
+            if (inferredMember?.isClassMember &&
+                !inferredMember.isInstanceMember &&
+                (0, types_1.isFunctionOrOverloaded)(getTypeOfMember(inferredMember))) {
+                memberInfo = inferredMember;
+            }
+        }
         // If we couldn't find a symbol with a declared type, use
         // a symbol with an inferred type.
         if (!memberInfo) {
@@ -4747,7 +4871,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const subDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
         const methodTypeResult = getTypeOfBoundMember(errorNode, concreteMemberType, accessMethodName, 
         /* usage */ undefined, subDiag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */);
-        if (!methodTypeResult || methodTypeResult.typeErrors) {
+        const deferredMethodType = usage.method === 'get'
+            ? getDescriptorGetMethodWithDeferredSelfSpecialization(concreteMemberType, subDiag)
+            : undefined;
+        if ((!methodTypeResult || methodTypeResult.typeErrors) && !deferredMethodType) {
             // Provide special error messages for properties.
             if (types_1.ClassType.isPropertyClass(concreteMemberType) && usage.method !== 'get') {
                 const message = usage.method === 'set' ? localize_1.LocAddendum.propertyMissingSetter() : localize_1.LocAddendum.propertyMissingDeleter();
@@ -4759,9 +4886,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return { type: memberType };
         }
-        const methodClassType = methodTypeResult.classType;
-        let methodType = methodTypeResult.type;
-        if (methodTypeResult.typeErrors || !methodClassType) {
+        const methodClassType = methodTypeResult?.classType ?? concreteMemberType;
+        let methodType = deferredMethodType ?? methodTypeResult.type;
+        if (!methodClassType) {
             if (diag && subDiag) {
                 diag.addAddendum(subDiag);
             }
@@ -4922,6 +5049,65 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             memberAccessDeprecationInfo: deprecationInfo,
         };
     }
+    function getDescriptorGetMethodWithDeferredSelfSpecialization(concreteMemberType, diag) {
+        const member = (0, typeUtils_1.lookUpClassMember)(concreteMemberType, '__get__');
+        if (!member || !(0, types_1.isInstantiableClass)(member.unspecializedClassType)) {
+            return undefined;
+        }
+        const unspecializedClassType = member.unspecializedClassType;
+        const declaringClassType = member.classType;
+        if (!(0, types_1.isInstantiableClass)(declaringClassType)) {
+            return undefined;
+        }
+        const declaringObjectType = types_1.ClassType.cloneAsInstance(declaringClassType);
+        const unspecializedMethodType = getEffectiveTypeOfSymbol(member.symbol);
+        if (!(0, types_1.isFunctionOrOverloaded)(unspecializedMethodType)) {
+            return undefined;
+        }
+        // A class ParamSpec used in Concatenate within the self annotation needs to be
+        // solved from the concrete descriptor, rather than specialized before self is bound.
+        const classParamSpecs = types_1.ClassType.getTypeParams(unspecializedClassType).filter(types_1.isParamSpec);
+        if (classParamSpecs.length === 0) {
+            return undefined;
+        }
+        const signatures = (0, types_1.isFunction)(unspecializedMethodType)
+            ? [unspecializedMethodType]
+            : types_1.OverloadedType.getOverloads(unspecializedMethodType);
+        const shouldDefer = signatures.some((signature) => {
+            if (signature.shared.parameters.length === 0) {
+                return false;
+            }
+            const selfParamType = types_1.FunctionType.getParamType(signature, 0);
+            if (!(0, types_1.isClassInstance)(selfParamType) || !types_1.ClassType.isSameGenericClass(selfParamType, declaringObjectType)) {
+                return false;
+            }
+            class ConcatenateParamSpecWalker extends typeWalker_1.TypeWalker {
+                constructor() {
+                    super(...arguments);
+                    this.found = false;
+                }
+                visitFunction(type) {
+                    const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
+                    if (paramSpec &&
+                        types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(type).shared.parameters.length > 0 &&
+                        classParamSpecs.some((classParamSpec) => (0, types_1.isTypeSame)(paramSpec, classParamSpec))) {
+                        this.found = true;
+                        this.cancelWalk();
+                        return;
+                    }
+                    super.visitFunction(type);
+                }
+            }
+            const walker = new ConcatenateParamSpecWalker();
+            selfParamType.priv.typeArgs?.forEach((typeArg) => walker.walk(typeArg));
+            return walker.found;
+        });
+        if (!shouldDefer) {
+            return undefined;
+        }
+        return bindFunctionToClassOrObject(declaringObjectType, unspecializedMethodType, declaringClassType, 
+        /* treatConstructorAsClassMethod */ false, concreteMemberType, diag);
+    }
     function bindMethodForMemberAccess(type, concreteType, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount = 0) {
         // Check for an attempt to overwrite a final method.
         if (usage.method === 'set') {
@@ -6279,6 +6465,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 +6483,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 +7244,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 +7476,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 +12460,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 +12815,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.
@@ -13240,6 +13557,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Determine the effective metaclass.
             if (metaclassNode) {
                 let metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
+                if ((0, types_1.isAny)(metaclassType)) {
+                    metaclassType = types_1.UnknownType.create();
+                }
                 if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
                     if ((0, typeUtils_1.requiresSpecialization)(metaclassType, { ignorePseudoGeneric: true })) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.metaclassIsGeneric(), metaclassNode);
@@ -14643,7 +14963,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 +15686,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 +16503,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 +19646,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 +19756,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 +20254,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;
         }
@@ -20959,7 +21316,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (functionType.priv.strippedFirstParamType) {
                 return functionType;
             }
-            if (types_1.FunctionType.isInstanceMethod(functionType)) {
+            if (types_1.FunctionType.isInstanceMethod(functionType) && !treatConstructorAsClassMethod) {
                 // If the baseType is a metaclass, don't specialize the function.
                 if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
                     return functionType;
@@ -20976,8 +21333,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 return partiallySpecializeBoundMethod(baseType, functionType, diag, recursionCount, selfType ?? baseObj, stripFirstParam);
             }
-            if (types_1.FunctionType.isClassMethod(functionType) ||
-                (treatConstructorAsClassMethod && types_1.FunctionType.isConstructorMethod(functionType))) {
+            if (types_1.FunctionType.isClassMethod(functionType) || treatConstructorAsClassMethod) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
                 const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
                 return partiallySpecializeBoundMethod(baseClass, functionType, diag, recursionCount, clsType ?? baseClass, 
@@ -21341,6 +21697,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         validateInitSubclassArgs,
         isNodeReachable,
         isAfterNodeReachable,
+        isKeyPresentInTypedDict: (node) => codeFlowEngine.isKeyPresentInTypedDict(node),
         getNodeReachability,
         getAfterNodeReachability,
         isAsymmetricAccessorAssignment,
@@ -21396,6 +21753,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getNoneType,
         getUnionClassType,
         getTypeClassType,
+        getFunctionClassType,
         getBuiltInObject,
         getTypingType,
         getTypeCheckerInternalsType,
@@ -21424,6 +21782,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