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

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);
                         }
                     }
                 }
@@ -2449,15 +2449,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 +2851,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) {
@@ -4102,8 +4103,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 +4211,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 +4399,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 +4455,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
@@ -6947,7 +6951,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 +7305,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 +8125,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 +8142,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] };
     }
@@ -8451,7 +8471,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 +8534,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));
@@ -10221,7 +10241,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 +10361,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 +10798,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) {
@@ -11464,7 +11477,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 +11751,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;
                             }
@@ -14572,7 +14590,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 +14607,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) {
@@ -16917,31 +16938,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 +17495,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 +18115,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 +18144,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 +18157,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 +18171,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 +18201,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 +18222,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;
                 }
             }
         }