@zzzen/pyright-internal 1.2.0-dev.20231015 → 1.2.0-dev.20231029

package/dist/analyzer/typeEvaluator.js

@@ -1358,8 +1358,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const unboundMethodType = getTypeOfMember(memberInfo);
             if ((0, types_1.isFunction)(unboundMethodType) || (0, types_1.isOverloadedFunction)(unboundMethodType)) {
                 const boundMethod = bindFunctionToClassOrObject(types_1.ClassType.cloneAsInstance(classType), unboundMethodType, 
-                /* memberClass */ undefined, 
-                /* errorNode */ undefined, recursionCount, treatConstructorAsClassMember);
+                /* memberClass */ undefined, treatConstructorAsClassMember, 
+                /* firstParamType */ undefined, 
+                /* diag */ undefined, recursionCount);
                 if (boundMethod) {
                     return boundMethod;
                 }
@@ -1574,8 +1575,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (setItemMember) {
                         const setItemType = getTypeOfMember(setItemMember);
                         if ((0, types_1.isFunction)(setItemType)) {
-                            const boundFunction = bindFunctionToClassOrObject(baseType, setItemType, (0, types_1.isInstantiableClass)(setItemMember.classType) ? setItemMember.classType : undefined, expression, 
-                            /* recursionCount */ undefined, 
+                            const boundFunction = bindFunctionToClassOrObjectWithErrors(baseType, setItemType, (0, types_1.isInstantiableClass)(setItemMember.classType) ? setItemMember.classType : undefined, expression, 
                             /* treatConstructorAsClassMember */ false);
                             if (boundFunction && (0, types_1.isFunction)(boundFunction)) {
                                 if (boundFunction.details.parameters.length >= 2) {
@@ -1621,8 +1621,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloadedFunction)(declaredType)) {
                         if (bindFunction) {
-                            declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType, 
-                            /* memberClass */ undefined, expression);
+                            declaredType = bindFunctionToClassOrObjectWithErrors(classOrObjectBase, declaredType, 
+                            /* memberAccessClass */ undefined, expression);
                         }
                     }
                 }
@@ -1935,9 +1935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, 
         /* reference */ undefined, 
         /* targetSymbolId */ undefined, 
-        /* typeAtStart */ types_1.UnboundType.create(), {
-            skipNoReturnCallAnalysis: true,
-        });
+        /* typeAtStart */ types_1.UnboundType.create());
         return codeFlowResult.type !== undefined && !(0, types_1.isNever)(codeFlowResult.type);
     }
     // Determines whether there is a code flow path from sourceNode to sinkNode.
@@ -2449,15 +2447,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const boundType = types_1.TypeBase.isInstantiable(subtype)
                         ? (0, typeUtils_1.convertToInstantiable)(subtype.details.boundType)
                         : subtype.details.boundType;
-                    return subtype.details.isSynthesized
-                        ? boundType
-                        : (0, typeUtils_1.addConditionToType)(boundType, [
-                            {
-                                typeVarName: types_1.TypeVarType.getNameWithScope(subtype),
-                                constraintIndex: 0,
-                                isConstrainedTypeVar: false,
-                            },
-                        ]);
+                    // Handle Self and type[Self] specially.
+                    if (subtype.details.isSynthesizedSelf && (0, types_1.isClass)(boundType)) {
+                        return types_1.ClassType.cloneIncludeSubclasses(boundType);
+                    }
+                    return (0, typeUtils_1.addConditionToType)(boundType, [
+                        {
+                            typeVarName: types_1.TypeVarType.getNameWithScope(subtype),
+                            constraintIndex: 0,
+                            isConstrainedTypeVar: false,
+                        },
+                    ]);
                 }
                 // If this is a recursive type alias placeholder
                 // that hasn't yet been resolved, return it as is.
@@ -2849,8 +2849,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return memberType;
         }
         if ((0, types_1.isFunction)(memberType) || (0, types_1.isOverloadedFunction)(memberType)) {
-            const methodType = bindFunctionToClassOrObject(bindToClass || objType, memberType, classMember && (0, types_1.isInstantiableClass)(classMember.classType) ? classMember.classType : undefined, errorNode, 
-            /* recursionCount */ undefined, 
+            const methodType = bindFunctionToClassOrObjectWithErrors(bindToClass || objType, memberType, classMember && (0, types_1.isInstantiableClass)(classMember.classType) ? classMember.classType : undefined, errorNode, 
             /* treatConstructorAsClassMember */ false, 
             /* firstParamType */ bindToClass);
             if (methodType) {
@@ -2870,7 +2869,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function getTypeOfName(node, flags) {
-        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol;
@@ -3018,29 +3016,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type = types_1.UnknownType.create();
             }
         }
-        if ((0, types_1.isTypeVar)(type) &&
-            !type.details.isParamSpec &&
-            !type.isVariadicInUnion &&
-            (flags & 128 /* ExpectingInstantiableType */) === 0 &&
-            type.details.name === name) {
-            // Handle the special case of a PEP 604 union. These can appear within
-            // an implied type alias where we are not expecting a type.
-            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* BinaryOperation */ &&
-                node.parent.operator === 6 /* BitwiseOr */;
-            if (!isPep604Union) {
-                // A TypeVar in contexts where we're not expecting a type is
-                // simply a TypeVar or TypeVarTuple object.
-                const typeVarType = type.details.isVariadic
-                    ? getTypingType(node, 'TypeVarTuple')
-                    : getTypingType(node, 'TypeVar');
-                if (typeVarType && (0, types_1.isInstantiableClass)(typeVarType)) {
-                    type = types_1.ClassType.cloneAsInstance(typeVarType);
-                }
-                else {
-                    type = types_1.UnknownType.create();
-                }
-            }
-        }
+        type = convertTypeVarToRuntimeInstance(node, type, flags);
         if ((flags & 256 /* ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
@@ -3061,6 +3037,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
+    // If the type is a TypeVar and we're not expecting a type, convert
+    // a TypeVar or TypeVarTuple into a runtime type. We don't currently
+    // do this for ParamSpec (although we arguably should) because it's
+    // problematic for handling P.args and P.kwargs.
+    function convertTypeVarToRuntimeInstance(node, type, flags) {
+        var _a;
+        if (node.nodeType === 38 /* Name */ &&
+            (0, types_1.isTypeVar)(type) &&
+            node.value === type.details.name &&
+            !type.isVariadicInUnion &&
+            (flags & 128 /* ExpectingInstantiableType */) === 0) {
+            if ((flags & 33554432 /* SkipConvertParamSpecToRuntimeObject */) !== 0 && type.details.isParamSpec) {
+                return type;
+            }
+            // Handle the special case of a PEP 604 union. These can appear within
+            // an implied type alias where we are not expecting a type.
+            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* BinaryOperation */ &&
+                node.parent.operator === 6 /* BitwiseOr */;
+            if (!isPep604Union) {
+                // A TypeVar in contexts where we're not expecting a type is
+                // simply a runtime object.
+                if (type.details.runtimeClass) {
+                    type = types_1.ClassType.cloneAsInstance(type.details.runtimeClass);
+                }
+                else {
+                    type = types_1.UnknownType.create();
+                }
+            }
+        }
+        return type;
+    }
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (either a function or a lambda).
     function getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType) {
@@ -3386,15 +3393,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, isRescoped: false, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
-        const baseTypeFlags = 16777218 /* MemberAccessBaseDefaults */ |
-            (flags &
+        // Compute flags specifically for evaluating the left expression.
+        let leftExprFlags = 16777218 /* MemberAccessBaseDefaults */;
+        leftExprFlags |=
+            flags &
                 (256 /* ExpectingTypeAnnotation */ |
                     32768 /* VariableTypeAnnotation */ |
                     4 /* AllowForwardReferences */ |
                     524288 /* NotParsedByInterpreter */ |
                     2048 /* DisallowTypeVarsWithScopeId */ |
-                    8192 /* AssociateTypeVarsWithCurrentScope */));
-        const baseTypeResult = getTypeOfExpression(node.leftExpression, baseTypeFlags);
+                    8192 /* AssociateTypeVarsWithCurrentScope */);
+        // Handle special casing for ParamSpec "args" and "kwargs" accesses.
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0) {
+            const memberName = node.memberName.value;
+            if (memberName === 'args' || memberName === 'kwargs') {
+                leftExprFlags |= 33554432 /* SkipConvertParamSpecToRuntimeObject */;
+            }
+        }
+        const baseTypeResult = getTypeOfExpression(node.leftExpression, leftExprFlags);
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             return {
                 type: types_1.UnknownType.create(/* isIncomplete */ true),
@@ -4102,8 +4118,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         bindToClass = accessMethod.classType;
                                     }
                                 }
-                                let boundMethodType = bindFunctionToClassOrObject(lookupClass, methodType, bindToClass, errorNode, 
-                                /* recursionCount */ undefined, 
+                                let boundMethodType = bindFunctionToClassOrObjectWithErrors(lookupClass, methodType, bindToClass, errorNode, 
                                 /* treatConstructorAsClassMember */ undefined, isAccessedThroughMetaclass ? concreteSubtype : undefined);
                                 // The synthesized access method for the property may contain
                                 // type variables associated with the "bindToClass", so we need
@@ -4211,8 +4226,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             effectiveBindToType = (0, typeUtils_1.convertToInstance)(bindToType);
                         }
                     }
-                    return bindFunctionToClassOrObject(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(baseTypeClass) : baseTypeClass, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, 
-                    /* recursionCount */ undefined, treatConstructorAsClassMember, effectiveBindToType);
+                    // If the bind-to type is a specific class, add the "includeSubclasses" flag
+                    // to the type to indicate that it could be a subclass.
+                    if (effectiveBindToType && (0, types_1.isClass)(effectiveBindToType)) {
+                        effectiveBindToType = types_1.ClassType.cloneIncludeSubclasses(effectiveBindToType);
+                    }
+                    return bindFunctionToClassOrObjectWithErrors(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(baseTypeClass) : baseTypeClass, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, treatConstructorAsClassMember, effectiveBindToType);
                 }
             }
             if (usage.method === 'set') {
@@ -4395,7 +4414,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
             }
             if ((0, types_1.isFunction)(accessMemberType) || (0, types_1.isOverloadedFunction)(accessMemberType)) {
-                const boundMethodType = bindFunctionToClassOrObject(classType, accessMemberType, classType, errorNode);
+                const boundMethodType = bindFunctionToClassOrObjectWithErrors(classType, accessMemberType, classType, errorNode);
                 if (boundMethodType && ((0, types_1.isFunction)(boundMethodType) || (0, types_1.isOverloadedFunction)(boundMethodType))) {
                     const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(boundMethodType));
                     const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
@@ -4451,7 +4470,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const indexTypeResult = getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'get' }, flags);
+        const indexTypeResult = getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'get' }, flags & ~16777216 /* DisallowPep695TypeAlias */);
         if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
             // We limit type narrowing for index expressions to built-in types that are
             // known to have symmetric __getitem__ and __setitem__ methods (i.e. the value
@@ -5527,7 +5546,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */ | (flags & 4 /* AllowForwardReferences */));
         }
-        const argList = node.arguments.map((arg) => {
+        const argList = ParseTreeUtils.getArgumentsByRuntimeOrder(node).map((arg) => {
             const functionArg = {
                 valueExpression: arg.valueExpression,
                 argumentCategory: arg.argumentCategory,
@@ -6947,7 +6966,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const remainingArgCount = positionalArgCount - argIndex;
             const remainingParamCount = positionParamLimitIndex - paramIndex - 1;
             if (paramIndex >= positionParamLimitIndex) {
-                if (!typeResult.type.details.paramSpec) {
+                if (paramSpecArgList) {
+                    // Push the remaining positional args onto the param spec arg list.
+                    while (argIndex < positionalArgCount) {
+                        paramSpecArgList.push(argList[argIndex]);
+                        argIndex++;
+                    }
+                }
+                else {
                     let tooManyPositionals = false;
                     if (foundUnpackedListArg && argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
                         // If this is an unpacked iterable, we will conservatively assume that it
@@ -7294,14 +7320,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if (typeResult.type.details.paramSpec &&
                         (0, parameterUtils_1.isParamSpecKwargsArgument)(typeResult.type.details.paramSpec, argType)) {
                         unpackedDictionaryArgType = types_1.AnyType.create();
-                        validateArgTypeParams.push({
-                            paramCategory: 2 /* KwargsDict */,
-                            paramType: typeResult.type.details.paramSpec,
-                            requiresTypeVarMatching: false,
-                            argument: argList[argIndex],
-                            argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
-                            errorNode: argList[argIndex].valueExpression || errorNode,
-                        });
+                        if (!paramSpecArgList) {
+                            validateArgTypeParams.push({
+                                paramCategory: 2 /* KwargsDict */,
+                                paramType: typeResult.type.details.paramSpec,
+                                requiresTypeVarMatching: false,
+                                argument: argList[argIndex],
+                                argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
+                                errorNode: argList[argIndex].valueExpression || errorNode,
+                            });
+                        }
                     }
                     else {
                         const strObjType = getBuiltInObject(errorNode, 'str');
@@ -8112,13 +8140,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { argumentErrors: paramSpecArgResult.argumentErrors, typeVarContexts };
     }
     function validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext, signatureTracker) {
-        var _a;
-        const paramSpecType = typeVarContext.getParamSpecType(paramSpec);
+        let paramSpecType = typeVarContext.getParamSpecType(paramSpec);
         if (!paramSpecType) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotBound().format({ type: printType(paramSpec) }), ((_a = argList[0]) === null || _a === void 0 ? void 0 : _a.valueExpression) || errorNode);
-            return { argumentErrors: true, typeVarContexts: [undefined] };
+            paramSpecType = (0, typeUtils_1.convertTypeToParamSpecValue)(paramSpec);
         }
         const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: paramSpecType }, 0);
+        const functionType = matchResults.overload;
         const srcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(paramSpecType));
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
@@ -8130,6 +8157,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             return { argumentErrors: true, typeVarContexts: [srcTypeVarContext] };
         }
+        // Handle the recursive case where we're passing (*args: P.args, **kwargs: P.args)
+        // a remaining function of type (*P).
+        if (functionType.details.paramSpec &&
+            functionType.details.parameters.length === 0 &&
+            (0, types_1.isTypeSame)(functionType.details.paramSpec, paramSpec)) {
+            // TODO - need to perform additional validation here.
+            return { argumentErrors: false, typeVarContexts: [srcTypeVarContext] };
+        }
         const result = validateFunctionArgumentTypes(errorNode, matchResults, srcTypeVarContext, signatureTracker);
         return { argumentErrors: !!result.argumentErrors, typeVarContexts: [srcTypeVarContext] };
     }
@@ -8435,7 +8470,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false);
+        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false, classType);
         // Parse the remaining parameters.
         const paramNameMap = new Map();
         for (let i = 1; i < argList.length; i++) {
@@ -8451,7 +8486,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else {
                         const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
-                        if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
+                        if ((0, typeUtils_1.requiresSpecialization)(argType, { ignorePseudoGeneric: true, ignoreImplicitTypeArgs: true })) {
                             addError(localize_1.Localizer.Diagnostic.typeVarBoundGeneric(), argList[i].valueExpression || errorNode);
                         }
                         typeVar.details.boundType = (0, typeUtils_1.convertToInstance)(argType);
@@ -8514,7 +8549,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else {
                     const argType = (_g = (_f = argList[i].typeResult) === null || _f === void 0 ? void 0 : _f.type) !== null && _g !== void 0 ? _g : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
-                    if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
+                    if ((0, typeUtils_1.requiresSpecialization)(argType, { ignorePseudoGeneric: true })) {
                         addError(localize_1.Localizer.Diagnostic.typeVarConstraintGeneric(), argList[i].valueExpression || errorNode);
                     }
                     types_1.TypeVarType.addConstraint(typeVar, (0, typeUtils_1.convertToInstance)(argType));
@@ -8561,7 +8596,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false);
+        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false, classType);
         typeVar.details.isVariadic = true;
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
@@ -8613,7 +8648,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.paramSpecFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const paramSpec = types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true);
+        const paramSpec = types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true, classType);
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
             const paramNameNode = argList[i].name;
@@ -9598,12 +9633,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type: returnedType };
     }
     function getTypeOfLambda(node, inferenceContext) {
-        let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
-        const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
-        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
-        // Pre-cache the incomplete function type in case the evaluation of the
-        // lambda depends on itself.
-        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
         let expectedFunctionTypes = [];
         if (inferenceContext) {
             (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (subtype) => {
@@ -9618,25 +9647,34 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return undefined;
             });
-            // Determine the minimum number of parameters that are required to
-            // satisfy the lambda.
-            const minLambdaParamCount = node.parameters.filter((param) => param.category === 0 /* Simple */ && !!param.name && param.defaultValue === undefined).length;
-            const maxLambdaParamCount = node.parameters.filter((param) => param.category === 0 /* Simple */ && !!param.name).length;
-            // Remove any expected subtypes that don't satisfy the minimum
-            // parameter count requirement.
-            expectedFunctionTypes = expectedFunctionTypes.filter((functionType) => {
-                const functionParamCount = functionType.details.parameters.filter((param) => !!param.name && !param.hasDefault).length;
-                const hasVarArgs = functionType.details.parameters.some((param) => !!param.name && param.category !== 0 /* Simple */);
-                const hasParamSpec = !!functionType.details.paramSpec;
-                return (hasVarArgs ||
-                    hasParamSpec ||
-                    (functionParamCount >= minLambdaParamCount && functionParamCount <= maxLambdaParamCount));
-            });
         }
-        // For now, use only the first expected type.
-        const expectedFunctionType = expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined;
+        if (expectedFunctionTypes.length <= 1) {
+            return getTypeOfLambdaWithExpectedType(node, expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined, inferenceContext, 
+            /* forceSpeculative */ false);
+        }
+        // Sort the expected types for deterministic results.
+        expectedFunctionTypes = (0, typeUtils_1.sortTypes)(expectedFunctionTypes);
+        // If there's more than one type, try each in turn until we find one that works.
+        for (const expectedFunctionType of expectedFunctionTypes) {
+            const result = getTypeOfLambdaWithExpectedType(node, expectedFunctionType, inferenceContext, 
+            /* forceSpeculative */ true);
+            if (!result.typeErrors) {
+                return getTypeOfLambdaWithExpectedType(node, expectedFunctionType, inferenceContext, 
+                /* forceSpeculative */ false);
+            }
+        }
+        return getTypeOfLambdaWithExpectedType(node, expectedFunctionTypes[0], inferenceContext, 
+        /* forceSpeculative */ true);
+    }
+    function getTypeOfLambdaWithExpectedType(node, expectedType, inferenceContext, forceSpeculative) {
+        let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
         let paramsArePositionOnly = true;
-        const expectedParamDetails = expectedFunctionType ? (0, parameterUtils_1.getParameterListDetails)(expectedFunctionType) : undefined;
+        const expectedParamDetails = expectedType ? (0, parameterUtils_1.getParameterListDetails)(expectedType) : undefined;
+        const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
+        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        // Pre-cache the incomplete function type in case the evaluation of the
+        // lambda depends on itself.
+        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
         node.parameters.forEach((param, index) => {
             let paramType;
             if (expectedParamDetails) {
@@ -9701,9 +9739,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        const expectedReturnType = expectedFunctionType
-            ? getFunctionEffectiveReturnType(expectedFunctionType)
-            : undefined;
+        const expectedReturnType = expectedType ? getFunctionEffectiveReturnType(expectedType) : undefined;
+        let typeErrors = false;
         // If we're speculatively evaluating the lambda, create another speculative
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
@@ -9711,19 +9748,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cache the type of the lambda return expression because it depends on
         // the parameter types that we set above, and the speculative type cache
         // doesn't know about that context.
-        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
+        useSpeculativeMode(forceSpeculative || isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)
+            ? node.expression
+            : undefined, () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
             /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (returnTypeResult.typeErrors) {
+                typeErrors = true;
+            }
         }, {
-            dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
+            dependentType: expectedType,
         });
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
-        return { type: functionType, isIncomplete };
+        // Is the resulting function compatible with the expected type?
+        if (expectedType && !assignType(expectedType, functionType)) {
+            typeErrors = true;
+        }
+        return { type: functionType, isIncomplete, typeErrors };
     }
     function getTypeOfListComprehension(node, inferenceContext) {
         var _a;
@@ -10221,7 +10267,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const type = typeArgs[0].type;
         // A ClassVar should not allow TypeVars or generic types parameterized
         // by TypeVars.
-        if ((0, typeUtils_1.requiresSpecialization)(type, /* ignorePseudoGeneric */ true, /* ignoreSelf */ true)) {
+        if ((0, typeUtils_1.requiresSpecialization)(type, { ignorePseudoGeneric: true, ignoreSelf: true })) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classVarWithTypeVar(), (_a = typeArgs[0].node) !== null && _a !== void 0 ? _a : errorNode);
         }
@@ -10341,8 +10387,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isRequired = classType.details.name === 'Required';
             isNotRequired = classType.details.name === 'NotRequired';
         }
-        isRequired = classType.details.name === 'Required';
-        isNotRequired = classType.details.name === 'NotRequired';
         if (!isUsageLegal) {
             addError(classType.details.name === 'ReadOnly'
                 ? localize_1.Localizer.Diagnostic.readOnlyNotInTypedDict()
@@ -10780,12 +10824,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ['LiteralString', { alias: '', module: 'builtins' }],
             ['ReadOnly', { alias: '', module: 'builtins' }],
         ]);
-        let aliasMapEntry = specialTypes.get(assignedName);
-        // Support ReadOnly only as an experimental feature.
-        if (assignedName === 'ReadOnly' &&
-            !AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
-            aliasMapEntry = undefined;
-        }
+        const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
             const cachedType = readTypeCache(node, 0 /* None */);
             if (cachedType) {
@@ -11315,8 +11354,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         metaclassNode = arg.valueExpression;
                     }
                 }
-                else if (types_1.ClassType.isTypedDictClass(classType) &&
-                    (arg.name.value === 'total' || arg.name.value === 'readonly')) {
+                else if (types_1.ClassType.isTypedDictClass(classType) && arg.name.value === 'total') {
                     // The "total" and "readonly" parameters apply only for TypedDict classes.
                     // PEP 589 specifies that the parameter must be either True or False.
                     const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
@@ -11326,9 +11364,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if (arg.name.value === 'total' && !constArgValue) {
                         classType.details.flags |= 256 /* CanOmitDictValues */;
                     }
-                    else if (arg.name.value === 'readonly' && constArgValue) {
-                        classType.details.flags |= 512 /* DictValuesReadOnly */;
-                    }
                 }
                 else {
                     // Collect arguments that will be passed to the `__init_subclass__`
@@ -11464,7 +11499,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (metaclassNode) {
                 const metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
                 if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
-                    if ((0, typeUtils_1.requiresSpecialization)(metaclassType, /* ignorePseudoGeneric */ true)) {
+                    if ((0, typeUtils_1.requiresSpecialization)(metaclassType, { ignorePseudoGeneric: true })) {
                         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.metaclassIsGeneric(), metaclassNode);
                     }
                     classType.details.declaredMetaclass = metaclassType;
@@ -11738,7 +11773,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         else if (!(0, typeUtils_1.derivesFromClassRecursive)(effectiveMetaclass, baseClassMeta, /* ignoreUnknown */ false)) {
                             if (!reportedMetaclassConflict) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.metaclassConflict(), errorNode);
+                                const diag = new diagnostic_1.DiagnosticAddendum();
+                                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.metaclassConflict().format({
+                                    metaclass1: printType((0, typeUtils_1.convertToInstance)(effectiveMetaclass)),
+                                    metaclass2: printType((0, typeUtils_1.convertToInstance)(baseClassMeta)),
+                                }));
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.metaclassConflict() + diag.getString(), errorNode);
                                 // Don't report more than once.
                                 reportedMetaclassConflict = true;
                             }
@@ -14216,6 +14256,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 .getDeclarations()
                                 .find((decl) => decl.type === 2 /* Parameter */);
                         }
+                        const parameterDetails = (0, parameterUtils_1.getParameterListDetails)(type);
+                        if (parameterDetails.unpackedKwargsTypedDictType) {
+                            const lookupResults = (0, typeUtils_1.lookUpClassMember)(parameterDetails.unpackedKwargsTypedDictType, paramName);
+                            if (lookupResults) {
+                                return lookupResults.symbol
+                                    .getDeclarations()
+                                    .find((decl) => decl.type === 1 /* Variable */);
+                            }
+                        }
                     }
                 }
             }
@@ -14556,13 +14605,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (cachedTypeVarType && (0, types_1.isTypeVar)(cachedTypeVarType)) {
             return cachedTypeVarType;
         }
-        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value);
-        typeVar.details.isTypeParamSyntax = true;
+        let runtimeClassName = 'TypeVar';
         if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
-            typeVar.details.isVariadic = true;
+            runtimeClassName = 'TypeVarTuple';
         }
         else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
-            typeVar.details.isParamSpec = true;
+            runtimeClassName = 'ParamSpec';
+        }
+        const runtimeType = getTypingType(node, runtimeClassName);
+        const runtimeClass = runtimeType && (0, types_1.isInstantiableClass)(runtimeType) ? runtimeType : undefined;
+        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value, node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec, runtimeClass);
+        typeVar.details.isTypeParamSyntax = true;
+        if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
+            typeVar.details.isVariadic = true;
         }
         // Cache the value before we evaluate the bound or the default type in
         // case it refers to itself in a circular manner.
@@ -14572,7 +14627,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (node.boundExpression.nodeType === 52 /* Tuple */) {
                 const constraints = node.boundExpression.expressions.map((constraint) => {
                     const constraintType = getTypeOfExpressionExpectingType(constraint).type;
-                    if ((0, typeUtils_1.requiresSpecialization)(constraintType, /* ignorePseudoGeneric */ true)) {
+                    if ((0, typeUtils_1.requiresSpecialization)(constraintType, {
+                        ignorePseudoGeneric: true,
+                        ignoreImplicitTypeArgs: true,
+                    })) {
                         addError(localize_1.Localizer.Diagnostic.typeVarBoundGeneric(), constraint);
                     }
                     return (0, typeUtils_1.convertToInstance)(constraintType);
@@ -14586,7 +14644,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else {
                 const boundType = getTypeOfExpressionExpectingType(node.boundExpression).type;
-                if ((0, typeUtils_1.requiresSpecialization)(boundType, /* ignorePseudoGeneric */ true)) {
+                if ((0, typeUtils_1.requiresSpecialization)(boundType, { ignorePseudoGeneric: true })) {
                     addError(localize_1.Localizer.Diagnostic.typeVarConstraintGeneric(), node.boundExpression);
                 }
                 if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
@@ -14888,7 +14946,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
-        var _a, _b;
         let declaredTypeInfo;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
@@ -14921,13 +14978,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let cacheEntries = effectiveTypeCache.get(symbol.id);
         const usageNodeId = usageNode ? usageNode.id : undefined;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
-        if (cacheEntries) {
-            const result = cacheEntries.get(effectiveTypeCacheKey);
-            if (result) {
-                if (!result.isIncomplete) {
-                    return result;
-                }
-            }
+        const cacheEntry = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey);
+        if (cacheEntry && !cacheEntry.isIncomplete) {
+            return cacheEntry;
         }
         // Infer the type.
         const decls = symbol.getDeclarations();
@@ -15016,8 +15069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             declsToConsider.push(resolvedDecl);
         });
-        const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
-        const result = getTypeOfSymbolForDecls(symbol, declsToConsider, evaluationAttempts);
+        const result = getTypeOfSymbolForDecls(symbol, declsToConsider, effectiveTypeCacheKey);
         // Add the result to the effective type cache if it doesn't include speculative results.
         if (!result.includesSpeculativeResult) {
             addToEffectiveTypeCache(result);
@@ -15033,7 +15085,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     // Returns the type of a symbol based on a subset of its declarations.
-    function getTypeOfSymbolForDecls(symbol, decls, evaluationAttempts) {
+    function getTypeOfSymbolForDecls(symbol, decls, typeCacheKey) {
+        var _a, _b;
         const typesToCombine = [];
         let isIncomplete = false;
         let sawPendingEvaluation = false;
@@ -15101,6 +15154,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 sawPendingEvaluation = true;
             }
         });
+        // How many times have we already attempted to evaluate this declaration already?
+        const cacheEntries = effectiveTypeCache.get(symbol.id);
+        const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(typeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
         let type;
         if (typesToCombine.length > 0) {
             // Ignore the pending evaluation flag if we've already attempted the
@@ -16917,31 +16973,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let specializedSrcType = srcType;
         let specializedDestType = destType;
-        let reverseMatchingFailed = false;
+        let doSpecializationStep = false;
         if ((flags & 2 /* ReverseTypeVarMatching */) === 0) {
             specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext, { useNarrowBoundOnly: true });
-            if ((0, typeUtils_1.requiresSpecialization)(specializedDestType)) {
-                reverseMatchingFailed = !assignType(specializedSrcType, specializedDestType, 
-                /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount);
-                specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext);
-            }
+            doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedDestType);
         }
         else {
             specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext, { useNarrowBoundOnly: true });
-            if ((0, typeUtils_1.requiresSpecialization)(specializedSrcType)) {
-                reverseMatchingFailed = !assignType(specializedSrcType, specializedDestType, 
-                /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount);
-                specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext);
+            doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedSrcType);
+        }
+        // Is an additional specialization step required?
+        if (doSpecializationStep) {
+            assignType(specializedSrcType, specializedDestType, 
+            /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount);
+            if ((flags & 2 /* ReverseTypeVarMatching */) === 0) {
+                specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext);
             }
-            if (reverseMatchingFailed) {
-                if (diag && paramIndex !== undefined) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramAssignment().format({
-                        index: paramIndex + 1,
-                        sourceType: printType(destType),
-                        destType: printType(srcType),
-                    }));
-                }
-                return false;
+            else {
+                specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext);
             }
         }
         // Handle the special case where the source is a Self type and the
@@ -17481,13 +17530,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         recursionCount++;
-        // If this is a tuple with defined tuple type arguments, don't overwrite them.
-        if (assignedType.tupleTypeArguments) {
-            return undefined;
-        }
         if (assignedType.details.typeParameters.length > 0 &&
             assignedType.typeArguments &&
-            assignedType.typeArguments.length <= assignedType.details.typeParameters.length) {
+            assignedType.typeArguments.length <= assignedType.details.typeParameters.length &&
+            !assignedType.tupleTypeArguments) {
             const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(assignedType));
             (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneForSpecialization(assignedType, 
             /* typeArguments */ undefined, 
@@ -18104,13 +18150,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return methodList;
     }
+    function bindFunctionToClassOrObjectWithErrors(baseType, memberType, memberClass, errorNode, treatConstructorAsClassMember = false, firstParamType) {
+        const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
+        const result = bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember, firstParamType, diag);
+        if (!result && errorNode && diag) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, diag.getString(), errorNode);
+        }
+        return result;
+    }
     // If the memberType is an instance or class method, creates a new
     // version of the function that has the "self" or "cls" parameter bound
     // to it. If treatAsClassMethod is true, the function is treated like a
     // class method even if it's not marked as such. That's needed to
     // special-case the __new__ magic method when it's invoked as a
     // constructor (as opposed to by name).
-    function bindFunctionToClassOrObject(baseType, memberType, memberClass, errorNode, recursionCount = 0, treatConstructorAsClassMember = false, firstParamType) {
+    function bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember = false, firstParamType, diag, recursionCount = 0) {
         if ((0, types_1.isFunction)(memberType)) {
             // If the caller specified no base type, always strip the
             // first parameter. This is used in cases like constructors.
@@ -18125,7 +18179,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const baseObj = (0, types_1.isClassInstance)(baseType)
                     ? baseType
                     : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType));
-                return partiallySpecializeFunctionForBoundClassOrObject(baseType, memberType, memberClass || types_1.ClassType.cloneAsInstantiable(baseObj), errorNode, recursionCount, firstParamType || baseObj, 
+                return partiallySpecializeFunctionForBoundClassOrObject(baseType, memberType, memberClass || types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, firstParamType || baseObj, 
                 /* stripFirstParam */ (0, types_1.isClassInstance)(baseType));
             }
             if (types_1.FunctionType.isClassMethod(memberType) ||
@@ -18138,12 +18192,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         ? firstParamType
                         : (0, typeUtils_1.convertToInstantiable)(firstParamType)
                     : baseClass;
-                return partiallySpecializeFunctionForBoundClassOrObject(types_1.TypeBase.isInstance(baseType) ? types_1.ClassType.cloneAsInstantiable(baseType) : baseType, memberType, memberClass || baseClass, errorNode, recursionCount, effectiveFirstParamType, 
+                return partiallySpecializeFunctionForBoundClassOrObject(types_1.TypeBase.isInstance(baseType) ? types_1.ClassType.cloneAsInstantiable(baseType) : baseType, memberType, memberClass || baseClass, diag, recursionCount, effectiveFirstParamType, 
                 /* stripFirstParam */ true);
             }
             if (types_1.FunctionType.isStaticMethod(memberType)) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
-                return partiallySpecializeFunctionForBoundClassOrObject(types_1.TypeBase.isInstance(baseType) ? types_1.ClassType.cloneAsInstantiable(baseType) : baseType, memberType, memberClass || baseClass, errorNode, recursionCount, 
+                return partiallySpecializeFunctionForBoundClassOrObject(types_1.TypeBase.isInstance(baseType) ? types_1.ClassType.cloneAsInstantiable(baseType) : baseType, memberType, memberClass || baseClass, diag, recursionCount, 
                 /* effectiveFirstParamType */ undefined, 
                 /* stripFirstParam */ false);
             }
@@ -18152,24 +18206,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const newOverloadType = types_1.OverloadedFunctionType.create([]);
             // Don't bother binding the implementation.
             types_1.OverloadedFunctionType.getOverloads(memberType).forEach((overload) => {
-                const boundMethod = bindFunctionToClassOrObject(baseType, overload, memberClass, 
-                /* errorNode */ undefined, recursionCount, treatConstructorAsClassMember, firstParamType);
+                const boundMethod = bindFunctionToClassOrObject(baseType, overload, memberClass, treatConstructorAsClassMember, firstParamType, 
+                /* diag */ undefined, recursionCount);
                 if (boundMethod) {
                     types_1.OverloadedFunctionType.addOverload(newOverloadType, boundMethod);
                 }
             });
-            if (types_1.OverloadedFunctionType.getOverloads(newOverloadType).length === 0) {
-                // No overloads matched, so rebind with the errorNode
+            const newOverloads = types_1.OverloadedFunctionType.getOverloads(newOverloadType);
+            if (newOverloads.length === 0) {
+                // No overloads matched, so rebind with the diag
                 // to report the error(s) to the user.
-                if (errorNode) {
+                if (diag) {
                     memberType.overloads.forEach((overload) => {
-                        bindFunctionToClassOrObject(baseType, overload, memberClass, errorNode, recursionCount, treatConstructorAsClassMember, firstParamType);
+                        bindFunctionToClassOrObject(baseType, overload, memberClass, treatConstructorAsClassMember, firstParamType, diag, recursionCount);
                     });
                 }
                 return undefined;
             }
-            else if (newOverloadType.overloads.length === 1) {
-                return newOverloadType.overloads[0];
+            if (newOverloads.length === 1) {
+                return newOverloads[0];
             }
             return newOverloadType;
         }
@@ -18181,14 +18236,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // is the type used to reference the member, and the memberClass
     // is the class that provided the member (could be an ancestor of
     // the baseType's class).
-    function partiallySpecializeFunctionForBoundClassOrObject(baseType, memberType, memberClass, errorNode, recursionCount, firstParamType, stripFirstParam = true) {
+    function partiallySpecializeFunctionForBoundClassOrObject(baseType, memberType, memberClass, diag, recursionCount, firstParamType, stripFirstParam = true) {
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(memberClass));
         if (firstParamType && memberType.details.parameters.length > 0) {
             const memberTypeFirstParam = memberType.details.parameters[0];
             const memberTypeFirstParamType = types_1.FunctionType.getEffectiveParameterType(memberType, 0);
             // Fill out the typeVarContext for the "self" or "cls" parameter.
             typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(memberType));
-            const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
             if ((0, types_1.isTypeVar)(memberTypeFirstParamType) &&
                 memberTypeFirstParamType.details.boundType &&
                 (0, types_1.isClassInstance)(memberTypeFirstParamType.details.boundType) &&
@@ -18203,25 +18257,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         : firstParamType);
                 }
             }
-            else if (!assignType(memberTypeFirstParamType, firstParamType, diag, typeVarContext, 
+            else if (!assignType(memberTypeFirstParamType, firstParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), typeVarContext, 
             /* srcTypeVarContext */ undefined, 2048 /* AllowUnspecifiedTypeArguments */, recursionCount)) {
                 if (memberTypeFirstParam.name &&
                     !memberTypeFirstParam.isNameSynthesized &&
                     memberTypeFirstParam.hasDeclaredType) {
-                    if (errorNode) {
-                        const methodName = memberType.details.name || '(unnamed)';
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.bindTypeMismatch().format({
+                    if (diag) {
+                        diag.addMessage(localize_1.Localizer.Diagnostic.bindTypeMismatch().format({
                             type: printType(baseType),
-                            methodName: methodName,
+                            methodName: memberType.details.name || '<anonymous>',
                             paramName: memberTypeFirstParam.name,
-                        }) + (diag === null || diag === void 0 ? void 0 : diag.getString()), errorNode);
-                    }
-                    else {
-                        // If there was no errorNode, we couldn't report the error,
-                        // so we will instead return undefined and let the caller
-                        // deal with the error.
-                        return undefined;
+                        }));
                     }
+                    return undefined;
                 }
             }
         }