@zzzen/pyright-internal 1.2.0-dev.20231105 → 1.2.0-dev.20231112

package/dist/analyzer/typeEvaluator.js

@@ -1297,9 +1297,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // using the objectType parameter. Callers can specify these separately
     // to handle the case where we're fetching the object member from a
     // metaclass but binding to the class.
-    function getTypeOfObjectMember(errorNode, objectType, memberName, usage = { method: 'get' }, diag = undefined, flags = 0 /* Default */, selfType) {
+    function getTypeOfBoundMember(errorNode, objectType, memberName, usage = { method: 'get' }, diag = undefined, flags = 0 /* Default */, selfType, recursionCount = 0) {
         if (types_1.ClassType.isPartiallyEvaluated(objectType)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classDefinitionCycle().format({ name: objectType.details.name }), errorNode);
+            if (errorNode) {
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classDefinitionCycle().format({ name: objectType.details.name }), errorNode);
+            }
             return { type: types_1.UnknownType.create() };
         }
         // Determine the class that was used to instantiate the objectType.
@@ -1357,7 +1359,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 effectiveFlags &= ~16 /* SkipInstanceMembers */;
             }
             const metaclassDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
-            memberInfo = getTypeOfClassMemberName(errorNode, types_1.ClassType.cloneAsInstance(metaclass), memberName, usage, metaclassDiag, effectiveFlags, objectTypeIsInstantiable ? objectType : types_1.ClassType.cloneAsInstantiable(objectType));
+            memberInfo = getTypeOfClassMemberName(errorNode, types_1.ClassType.cloneAsInstance(metaclass), memberName, usage, metaclassDiag, effectiveFlags, objectTypeIsInstantiable ? objectType : types_1.ClassType.cloneAsInstantiable(objectType), recursionCount);
             // If there was a descriptor error (as opposed to an error where the members
             // was simply not found), use this diagnostic message.
             if (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.isDescriptorError) {
@@ -1378,20 +1380,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function getBoundMethod(classType, memberName, recursionCount = 0) {
-        const memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, 16 /* SkipInstanceMembers */);
-        if (!memberInfo) {
+    function getBoundMagicMethod(classType, memberName, selfType, recursionCount = 0) {
+        const boundMethodResult = getTypeOfBoundMember(
+        /* errorNode */ undefined, classType, memberName, 
+        /* usage */ undefined, 
+        /* diag */ undefined, 16 /* SkipInstanceMembers */ | 512 /* SkipAttributeAccessOverride */, selfType, recursionCount);
+        if (!boundMethodResult || boundMethodResult.typeErrors) {
             return undefined;
         }
-        const unboundMethodType = getTypeOfMember(memberInfo);
-        if ((0, types_1.isFunction)(unboundMethodType) || (0, types_1.isOverloadedFunction)(unboundMethodType)) {
-            return bindFunctionToClassOrObject(types_1.ClassType.cloneAsInstance(classType), unboundMethodType, 
-            /* memberClass */ undefined, 
-            /* treatConstructorAsClassMember */ true, 
-            /* selfType */ undefined, 
-            /* diag */ undefined, recursionCount);
+        if ((0, types_1.isFunction)(boundMethodResult.type) || (0, types_1.isOverloadedFunction)(boundMethodResult.type)) {
+            return boundMethodResult.type;
         }
-        if ((0, types_1.isAnyOrUnknown)(unboundMethodType)) {
+        if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
             const unknownFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* SkipArgsKwargsCompatibilityCheck */);
             types_1.FunctionType.addDefaultParameters(unknownFunction);
             return unknownFunction;
@@ -1472,35 +1472,39 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 case 6 /* Class */: {
                     if (types_1.TypeBase.isInstantiable(subtype)) {
-                        let methodType;
+                        let constructorType;
                         // Try to get the `__init__` method first because it typically has more
                         // type information than `__new__`.
-                        methodType = getBoundMethod(subtype, '__init__');
-                        // Is this the __init__ method provided by the object class?
-                        const isObjectInit = !!methodType &&
-                            (0, types_1.isFunction)(methodType) &&
-                            methodType.details.fullName === 'builtins.object.__init__';
-                        const isDefaultParams = methodType && (0, types_1.isFunction)(methodType) && types_1.FunctionType.hasDefaultParameters(methodType);
+                        const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, callNode, types_1.ClassType.cloneAsInstance(subtype), 
+                        /* skipObjectBase */ false);
+                        if (initMethodResult && !initMethodResult.typeErrors && (0, types_1.isFunction)(initMethodResult.type)) {
+                            constructorType = initMethodResult.type;
+                        }
+                        const isObjectInit = constructorType &&
+                            (0, types_1.isFunction)(constructorType) &&
+                            constructorType.details.fullName === 'builtins.object.__init__';
+                        const isDefaultParams = constructorType &&
+                            (0, types_1.isFunction)(constructorType) &&
+                            types_1.FunctionType.hasDefaultParameters(constructorType);
                         // If there was no `__init__` or the only `__init__` that was found was from
                         // the `object` class or accepts only default parameters(* args, ** kwargs),
                         // see if we can find a better signature from the `__new__` method.
-                        if (!methodType || isObjectInit || isDefaultParams) {
-                            const constructorType = getBoundMethod(subtype, '__new__');
-                            if (constructorType) {
-                                // Is this the __new__ method provided by the object class?
-                                const isObjectNew = (0, types_1.isFunction)(constructorType) &&
-                                    constructorType.details.fullName === 'builtins.object.__new__';
-                                if (!isObjectNew) {
-                                    methodType = constructorType;
-                                }
+                        if (!constructorType || isObjectInit || isDefaultParams) {
+                            const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype, 
+                            /* skipObjectBase */ false);
+                            if (newMethodResult &&
+                                !newMethodResult.typeErrors &&
+                                (0, types_1.isFunction)(newMethodResult.type) &&
+                                newMethodResult.type.details.fullName !== 'builtins.object.__new__') {
+                                constructorType = newMethodResult.type;
                             }
                         }
-                        if (methodType) {
-                            addFunctionToSignature(methodType);
+                        if (constructorType) {
+                            addFunctionToSignature(constructorType);
                         }
                     }
                     else {
-                        const methodType = getBoundMethod(subtype, '__call__');
+                        const methodType = getBoundMagicMethod(subtype, '__call__');
                         if (methodType) {
                             addFunctionToSignature(methodType);
                         }
@@ -1635,20 +1639,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 24 /* Index */: {
                 const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.baseExpression, 2 /* IndexBaseDefaults */).type);
                 if (baseType && (0, types_1.isClassInstance)(baseType)) {
-                    const setItemMember = (0, typeUtils_1.lookUpClassMember)(baseType, '__setitem__');
-                    if (setItemMember) {
-                        const setItemType = getTypeOfMember(setItemMember);
-                        if ((0, types_1.isFunction)(setItemType)) {
-                            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) {
-                                    const paramType = types_1.FunctionType.getEffectiveParameterType(boundFunction, 1);
-                                    if (!(0, types_1.isAnyOrUnknown)(paramType)) {
-                                        return paramType;
-                                    }
-                                }
-                            }
+                    const setItemType = getBoundMagicMethod(baseType, '__setitem__');
+                    if (setItemType && (0, types_1.isFunction)(setItemType) && setItemType.details.parameters.length >= 2) {
+                        const paramType = types_1.FunctionType.getEffectiveParameterType(setItemType, 1);
+                        if (!(0, types_1.isAnyOrUnknown)(paramType)) {
+                            return paramType;
                         }
                     }
                     else if (types_1.ClassType.isTypedDictClass(baseType)) {
@@ -1666,14 +1661,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (declaredType) {
                 // If it's a descriptor, we need to get the setter type.
                 if (useDescriptorSetterType && (0, types_1.isClassInstance)(declaredType)) {
-                    const setterInfo = (0, typeUtils_1.lookUpClassMember)(declaredType, '__set__');
-                    const setter = setterInfo ? getTypeOfMember(setterInfo) : undefined;
-                    if (setterInfo && setter && (0, types_1.isFunction)(setter) && setter.details.parameters.length >= 3) {
-                        declaredType = setter.details.parameters[2].type;
-                        if ((0, types_1.isClass)(setterInfo.classType)) {
-                            const typeVarMap = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(setterInfo.classType);
-                            declaredType = (0, typeUtils_1.applySolvedTypeVars)(declaredType, typeVarMap);
-                        }
+                    const setter = getBoundMagicMethod(declaredType, '__set__');
+                    if (setter && (0, types_1.isFunction)(setter) && setter.details.parameters.length >= 2) {
+                        declaredType = setter.details.parameters[1].type;
                         if ((0, types_1.isAnyOrUnknown)(declaredType)) {
                             return undefined;
                         }
@@ -1685,8 +1675,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloadedFunction)(declaredType)) {
                         if (bindFunction) {
-                            declaredType = bindFunctionToClassOrObjectWithErrors(classOrObjectBase, declaredType, 
-                            /* memberAccessClass */ undefined, expression);
+                            declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType);
                         }
                     }
                 }
@@ -3323,7 +3312,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (typeParametersForScope) {
                 const match = typeParametersForScope.find((typeVar) => typeVar.details.name === type.details.name);
-                if (match === null || match === void 0 ? void 0 : match.scopeId) {
+                if ((match === null || match === void 0 ? void 0 : match.scopeId) !== undefined && match.scopeName !== undefined && match.scopeType !== undefined) {
                     // Use the scoped version of the TypeVar rather than the (unscoped) original type.
                     type = types_1.TypeVarType.cloneForScopeId(type, match.scopeId, match.scopeName, match.scopeType);
                     return {
@@ -3559,7 +3548,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }, usage, 0 /* None */);
             }
             case 6 /* Class */: {
-                const typeResult = (_a = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete)) !== null && _a !== void 0 ? _a : getTypeOfObjectMember(node.memberName, baseType, memberName, usage, diag, 
+                const typeResult = (_a = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete)) !== null && _a !== void 0 ? _a : getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
                 /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
                 if (typeResult) {
                     type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
@@ -3651,7 +3640,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return undefined;
                     }
                     if ((0, typeUtils_1.isNoneInstance)(subtype) && noneType && (0, types_1.isClassInstance)(noneType)) {
-                        const typeResult = getTypeOfObjectMember(node.memberName, noneType, memberName, usage, diag);
+                        const typeResult = getTypeOfBoundMember(node.memberName, noneType, memberName, usage, diag);
                         if (typeResult) {
                             type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
                             if (typeResult.isIncomplete) {
@@ -3732,8 +3721,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete, isAsymmetricAccessor, isRequired, isNotRequired, memberAccessDeprecationInfo };
     }
-    function getTypeOfClassMemberName(errorNode, classType, memberName, usage, diag, flags, selfType) {
-        var _a, _b, _c, _d;
+    function getTypeOfClassMemberName(errorNode, classType, memberName, usage, diag, flags, selfType, recursionCount = 0) {
+        var _a, _b, _c;
         const isAccessedThroughObject = types_1.TypeBase.isInstance(classType);
         // Always look for a member with a declared type first.
         let memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags | 64 /* DeclaredTypesOnly */);
@@ -3746,8 +3735,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // No attribute of that name was found. If this is a member access
             // through an object, see if there's an attribute access override
             // method ("__getattr__", etc.).
-            if ((flags & 512 /* SkipAttributeAccessOverride */) === 0) {
-                const generalAttrType = applyAttributeAccessOverride(classType, errorNode, usage, memberName, selfType);
+            if ((flags & 512 /* SkipAttributeAccessOverride */) === 0 && errorNode) {
+                const generalAttrType = applyAttributeAccessOverride(errorNode, classType, usage, memberName, selfType);
                 if (generalAttrType) {
                     return {
                         symbol: undefined,
@@ -3756,7 +3745,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         isDescriptorError: false,
                         isClassMember: false,
                         isClassVar: false,
-                        isAsymmetricAccessor: generalAttrType.isAsymmetricAccessor,
+                        isAsymmetricAccessor: !!generalAttrType.isAsymmetricAccessor,
                     };
                 }
             }
@@ -3770,7 +3759,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsInitVar().format({ name: memberName }));
             return undefined;
         }
-        if (usage.method !== 'get') {
+        if (usage.method !== 'get' && errorNode) {
             // If the usage indicates a 'set' or 'delete' and the access is within the
             // class definition itself, use only the declared type to avoid circular
             // type evaluation.
@@ -3805,23 +3794,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (!type) {
-            let selfClass = classType;
-            // Determine whether to replace Self variables with a specific
-            // class. Avoid doing this if there's a "selfType" specified
-            // because that case is used for super() calls where we want
-            // to leave the Self type generic (not specialized). We'll also
-            // skip this for __new__ methods because they are not bound
-            // to the class but rather assume the type of the cls argument.
+            let selfClass;
             if (selfType) {
-                if ((0, types_1.isTypeVar)(selfType) && selfType.details.isSynthesizedSelf) {
-                    selfClass = selfType;
-                }
-                else {
-                    selfClass = undefined;
-                }
+                selfClass = (0, typeUtils_1.convertToInstantiable)(selfType);
             }
-            else if (memberName === '__new__') {
-                selfClass = undefined;
+            else {
+                // Skip this for __new__ methods because they are not bound
+                // to the class but rather assume the type of the cls argument.
+                if (memberName !== '__new__') {
+                    selfClass = classType;
+                }
             }
             const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
             type = (_c = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
@@ -3839,7 +3821,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (usage.method === 'get') {
             // Mark the member accessed if it's not coming from a parent class.
-            if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
+            if (errorNode &&
+                (0, types_1.isInstantiableClass)(memberInfo.classType) &&
                 types_1.ClassType.isSameGenericClass(memberInfo.classType, classType)) {
                 setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(errorNode), memberInfo.symbol, errorNode);
             }
@@ -3852,32 +3835,96 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const descResult = applyDescriptorAccessMethod(type, memberInfo, classType, selfType, flags, errorNode, memberName, usage, diag);
-        let isDescriptorError = true;
-        if (descResult) {
-            isDescriptorError = false;
-            type = descResult.type;
-            if (usage.method === 'set' && usage.setType) {
-                // Verify that the assigned type is compatible.
-                if (!assignType(type, usage.setType.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
-                    if (!usage.setType.isIncomplete) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberAssignment().format({
-                            type: printType(usage.setType.type),
-                            name: memberName,
-                            classType: printObjectTypeForClass(classType),
-                        }));
-                    }
+        // If the member is a descriptor object, apply the descriptor protocol
+        // now. If the member is an instance or class method, bind the method.
+        let isDescriptorError = false;
+        let isAsymmetricAccessor = false;
+        let isDescriptorApplied = false;
+        let memberAccessDeprecationInfo;
+        type = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
+            const isClassMember = !memberInfo || memberInfo.isClassMember;
+            let resultType;
+            if ((0, types_1.isClass)(concreteSubtype) && isClassMember && errorNode) {
+                const descResult = applyDescriptorAccessMethod(subtype, concreteSubtype, memberInfo, classType, selfType, flags, errorNode, memberName, usage, diag);
+                if (descResult.isAsymmetricAccessor) {
+                    isAsymmetricAccessor = true;
+                }
+                if (descResult.memberAccessDeprecationInfo) {
+                    memberAccessDeprecationInfo = descResult.memberAccessDeprecationInfo;
+                }
+                if (descResult.typeErrors) {
                     isDescriptorError = true;
                 }
-                if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
-                    types_1.ClassType.isFrozenDataClass(memberInfo.classType) &&
-                    isAccessedThroughObject) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.dataClassFrozen().format({
-                        name: printType(types_1.ClassType.cloneAsInstance(memberInfo.classType)),
-                    }));
+                if (descResult.isDescriptorApplied) {
+                    isDescriptorApplied = true;
+                }
+                resultType = descResult.type;
+            }
+            else if ((0, types_1.isFunction)(concreteSubtype) || (0, types_1.isOverloadedFunction)(concreteSubtype)) {
+                const typeResult = bindMethodForMemberAccess(subtype, concreteSubtype, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount);
+                resultType = typeResult.type;
+                if (typeResult.typeErrors) {
+                    isDescriptorError = true;
+                }
+            }
+            else {
+                resultType = subtype;
+            }
+            // If this is a "set" operation, we have a bit more work to do.
+            if (usage.method !== 'set') {
+                return resultType;
+            }
+            // Check for an attempt to overwrite a ClassVar member from an instance.
+            if (!isDescriptorApplied &&
+                (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.isClassVar()) &&
+                (flags & 128 /* DisallowClassVarWrites */) !== 0) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberSetClassVar().format({ name: memberName }));
+                isDescriptorError = true;
+            }
+            // Check for an attempt to overwrite a final member variable.
+            const finalVarTypeDecl = memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.getDeclarations().find((decl) => isFinalVariableDeclaration(decl));
+            if (finalVarTypeDecl &&
+                errorNode &&
+                !ParseTreeUtils.isNodeContainedWithin(errorNode, finalVarTypeDecl.node)) {
+                // If a Final instance variable is declared in the class body but is
+                // being assigned within an __init__ method, it's allowed.
+                const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(errorNode);
+                if (!enclosingFunctionNode || enclosingFunctionNode.name.value !== '__init__') {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.finalReassigned().format({ name: memberName }));
                     isDescriptorError = true;
                 }
             }
+            // Check for an attempt to overwrite an instance variable that is
+            // read-only (e.g. in a named tuple).
+            if ((memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.isInstanceMember) &&
+                (0, types_1.isClass)(memberInfo.classType) &&
+                types_1.ClassType.isReadOnlyInstanceVariables(memberInfo.classType)) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.readOnlyAttribute().format({ name: memberName }));
+                isDescriptorError = true;
+            }
+            return resultType;
+        });
+        if (!isDescriptorError && usage.method === 'set' && usage.setType) {
+            // Verify that the assigned type is compatible.
+            if (!assignType(type, usage.setType.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
+                if (!usage.setType.isIncomplete) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberAssignment().format({
+                        type: printType(usage.setType.type),
+                        name: memberName,
+                        classType: printObjectTypeForClass(classType),
+                    }));
+                }
+                isDescriptorError = true;
+            }
+            if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
+                types_1.ClassType.isFrozenDataClass(memberInfo.classType) &&
+                isAccessedThroughObject) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.dataClassFrozen().format({
+                    name: printType(types_1.ClassType.cloneAsInstance(memberInfo.classType)),
+                }));
+                isDescriptorError = true;
+            }
         }
         return {
             symbol: memberInfo.symbol,
@@ -3887,329 +3934,208 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isClassMember: !memberInfo.isInstanceMember,
             isClassVar: memberInfo.isClassVar,
             classType: memberInfo.classType,
-            isAsymmetricAccessor: (_d = descResult === null || descResult === void 0 ? void 0 : descResult.isAsymmetricAccessor) !== null && _d !== void 0 ? _d : false,
-            memberAccessDeprecationInfo: descResult === null || descResult === void 0 ? void 0 : descResult.memberAccessDeprecationInfo,
+            isAsymmetricAccessor,
+            memberAccessDeprecationInfo,
         };
     }
     // Applies descriptor access methods "__get__", "__set__", or "__delete__"
-    // if they apply. Also binds methods to the class/object through which it
-    // is accessed.
-    function applyDescriptorAccessMethod(type, memberInfo, classType, selfType, flags, errorNode, memberName, usage, diag) {
-        const treatConstructorAsClassMember = (flags & 256 /* TreatConstructorAsClassMethod */) !== 0;
+    // if they apply.
+    function applyDescriptorAccessMethod(memberType, concreteMemberType, memberInfo, classType, selfType, flags, errorNode, memberName, usage, diag) {
+        var _a, _b, _c, _d;
         const isAccessedThroughObject = types_1.TypeBase.isInstance(classType);
-        let isTypeValid = true;
+        let accessMethodName;
+        if (usage.method === 'get') {
+            accessMethodName = '__get__';
+        }
+        else if (usage.method === 'set') {
+            accessMethodName = '__set__';
+        }
+        else {
+            accessMethodName = '__delete__';
+        }
+        const methodTypeResult = getTypeOfBoundMember(errorNode, concreteMemberType, accessMethodName, 
+        /* usage */ undefined, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 16 /* SkipInstanceMembers */ | 512 /* SkipAttributeAccessOverride */);
+        if (!methodTypeResult) {
+            // Provide special error messages for properties.
+            if (types_1.ClassType.isPropertyClass(concreteMemberType)) {
+                if (usage.method !== 'get') {
+                    const message = usage.method === 'set'
+                        ? localize_1.Localizer.DiagnosticAddendum.propertyMissingSetter()
+                        : localize_1.Localizer.DiagnosticAddendum.propertyMissingDeleter();
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(message.format({ name: memberName }));
+                    return { type: types_1.AnyType.create(), typeErrors: true };
+                }
+            }
+            return { type: memberType };
+        }
+        const methodClassType = methodTypeResult.classType;
+        let methodType = methodTypeResult.type;
+        if (methodTypeResult.typeErrors || !methodClassType) {
+            return { type: types_1.UnknownType.create(), typeErrors: true };
+        }
+        if (!(0, types_1.isFunction)(methodType) && !(0, types_1.isOverloadedFunction)(methodType)) {
+            if ((0, types_1.isAnyOrUnknown)(methodType)) {
+                return { type: methodType };
+            }
+            // TODO - emit an error for this condition.
+            return { type: memberType, typeErrors: true };
+        }
+        // Special-case logic for properties.
+        if (types_1.ClassType.isPropertyClass(concreteMemberType) &&
+            memberInfo &&
+            (0, types_1.isInstantiableClass)(memberInfo.classType) &&
+            methodType) {
+            // If the property is being accessed from a protocol class (not an instance),
+            // flag this as an error because a property within a protocol is meant to be
+            // interpreted as a read-only attribute rather than a protocol, so accessing
+            // it directly from the class has an ambiguous meaning.
+            if ((flags & 16 /* SkipInstanceMembers */) !== 0 && types_1.ClassType.isProtocolClass(classType)) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyAccessFromProtocolClass());
+                return { type: memberType, typeErrors: true };
+            }
+            // Infer return types before specializing. Otherwise a generic inferred
+            // return type won't be properly specialized.
+            inferReturnTypeIfNecessary(methodType);
+            // This specialization is required specifically for properties, which should be
+            // generic but are not defined that way. Because of this, we use type variables
+            // in the synthesized methods (e.g. __get__) for the property class that are
+            // defined in the class that declares the fget method.
+            const specializedType = (0, typeUtils_1.partiallySpecializeType)(methodType, memberInfo.classType, selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : classType);
+            if ((0, types_1.isFunction)(specializedType) || (0, types_1.isOverloadedFunction)(specializedType)) {
+                methodType = specializedType;
+            }
+        }
+        // Determine if we're calling __set__ on an asymmetric descriptor or property.
         let isAsymmetricAccessor = false;
-        let memberAccessDeprecationInfo;
-        type = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            var _a, _b, _c;
-            const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
-            const isClassMember = !memberInfo || memberInfo.isClassMember;
-            if ((0, types_1.isClass)(concreteSubtype) && isClassMember) {
-                // If it's an object, use its class to lookup the descriptor. If it's a class,
-                // use its metaclass instead.
-                let lookupClass = concreteSubtype;
-                let isAccessedThroughMetaclass = false;
-                if (types_1.TypeBase.isInstantiable(concreteSubtype)) {
-                    if (concreteSubtype.details.effectiveMetaclass &&
-                        (0, types_1.isInstantiableClass)(concreteSubtype.details.effectiveMetaclass)) {
-                        // When accessing a class member that is a class whose metaclass implements
-                        // a descriptor protocol, only 'get' operations are allowed. If it's accessed
-                        // through the object, all access methods are supported.
-                        if (isAccessedThroughObject || usage.method === 'get') {
-                            lookupClass = types_1.ClassType.cloneAsInstance(concreteSubtype.details.effectiveMetaclass);
-                            isAccessedThroughMetaclass = true;
-                        }
-                        else {
-                            lookupClass = undefined;
-                        }
-                    }
-                    else {
-                        lookupClass = undefined;
-                    }
-                }
-                if (lookupClass) {
-                    let accessMethodName;
-                    if (usage.method === 'get') {
-                        accessMethodName = '__get__';
-                    }
-                    else if (usage.method === 'set') {
-                        accessMethodName = '__set__';
-                    }
-                    else {
-                        accessMethodName = '__delete__';
-                    }
-                    const accessMethod = (0, typeUtils_1.lookUpClassMember)(lookupClass, accessMethodName, 16 /* SkipInstanceMembers */);
-                    // Handle properties specially.
-                    if (types_1.ClassType.isPropertyClass(lookupClass)) {
-                        if (usage.method === 'set') {
-                            if (!accessMethod) {
-                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMissingSetter().format({
-                                    name: memberName,
-                                }));
-                                isTypeValid = false;
-                                return undefined;
-                            }
-                        }
-                        else if (usage.method === 'del') {
-                            if (!accessMethod) {
-                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMissingDeleter().format({
-                                    name: memberName,
-                                }));
-                                isTypeValid = false;
-                                return undefined;
-                            }
-                        }
-                    }
-                    if (accessMethod) {
-                        let accessMethodType = getTypeOfMember(accessMethod);
-                        const argList = [
-                            {
-                                // Provide "obj" argument.
-                                argumentCategory: 0 /* Simple */,
-                                typeResult: {
-                                    type: types_1.ClassType.isClassProperty(lookupClass)
-                                        ? classType
-                                        : isAccessedThroughObject
-                                            ? selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType)
-                                            : getNoneType(),
-                                },
-                            },
-                        ];
-                        if (usage.method === 'get') {
-                            // Provide "owner" argument.
-                            argList.push({
-                                argumentCategory: 0 /* Simple */,
-                                typeResult: {
-                                    type: isAccessedThroughObject
-                                        ? types_1.ClassType.cloneAsInstantiable(classType)
-                                        : classType,
-                                },
-                            });
-                        }
-                        else if (usage.method === 'set') {
-                            // Provide "value" argument.
-                            argList.push({
-                                argumentCategory: 0 /* Simple */,
-                                typeResult: {
-                                    type: (_b = (_a = usage.setType) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create(),
-                                    isIncomplete: !!((_c = usage.setType) === null || _c === void 0 ? void 0 : _c.isIncomplete),
-                                },
-                            });
-                        }
-                        if (types_1.ClassType.isPropertyClass(lookupClass) &&
-                            memberInfo &&
-                            (0, types_1.isInstantiableClass)(memberInfo.classType)) {
-                            // This specialization is required specifically for properties, which should be
-                            // generic but are not defined that way. Because of this, we use type variables
-                            // in the synthesized methods (e.g. __get__) for the property class that are
-                            // defined in the class that declares the fget method.
-                            // Infer return types before specializing. Otherwise a generic inferred
-                            // return type won't be properly specialized.
-                            inferReturnTypeIfNecessary(accessMethodType);
-                            accessMethodType = (0, typeUtils_1.partiallySpecializeType)(accessMethodType, memberInfo.classType);
-                            // If the property is being accessed from a protocol class (not an instance),
-                            // flag this as an error because a property within a protocol is meant to be
-                            // interpreted as a read-only attribute rather than a protocol, so accessing
-                            // it directly from the class has an ambiguous meaning.
-                            if ((flags & 16 /* SkipInstanceMembers */) !== 0 &&
-                                types_1.ClassType.isProtocolClass(classType)) {
-                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyAccessFromProtocolClass());
-                                isTypeValid = false;
-                            }
-                        }
-                        if (accessMethodType &&
-                            ((0, types_1.isFunction)(accessMethodType) || (0, types_1.isOverloadedFunction)(accessMethodType))) {
-                            const methodType = accessMethodType;
-                            // Don't emit separate diagnostics for these method calls because
-                            // they will be redundant.
-                            const returnType = suppressDiagnostics(errorNode, () => {
-                                var _a;
-                                // Bind the accessor to the base object type.
-                                let bindToClass;
-                                // The "bind-to" class depends on whether the descriptor is defined
-                                // on the metaclass or the class. We handle properties specially here
-                                // because of the way we model the __get__ logic in the property class.
-                                if (types_1.ClassType.isPropertyClass(concreteSubtype) && !isAccessedThroughMetaclass) {
-                                    if (memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType)) {
-                                        bindToClass = types_1.ClassType.cloneAsInstance(memberInfo.classType);
-                                    }
-                                }
-                                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
-                                // to specialize those here.
-                                if (boundMethodType &&
-                                    ((0, types_1.isFunction)(boundMethodType) || (0, types_1.isOverloadedFunction)(boundMethodType))) {
-                                    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(boundMethodType));
-                                    if (bindToClass) {
-                                        const specializedBoundType = (0, typeUtils_1.partiallySpecializeType)(boundMethodType, bindToClass, classType);
-                                        if (specializedBoundType) {
-                                            if ((0, types_1.isFunction)(specializedBoundType) ||
-                                                (0, types_1.isOverloadedFunction)(specializedBoundType)) {
-                                                boundMethodType = specializedBoundType;
-                                            }
-                                        }
-                                    }
-                                    const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
-                                    /* skipUnknownArgCheck */ true);
-                                    if (callResult.overloadsUsedForCall &&
-                                        callResult.overloadsUsedForCall.length >= 1) {
-                                        const overloadUsed = callResult.overloadsUsedForCall[0];
-                                        if (overloadUsed.details.deprecatedMessage) {
-                                            memberAccessDeprecationInfo = {
-                                                deprecationMessage: overloadUsed.details.deprecatedMessage,
-                                                accessType: lookupClass && types_1.ClassType.isPropertyClass(lookupClass)
-                                                    ? 'property'
-                                                    : 'descriptor',
-                                                accessMethod: usage.method,
-                                            };
-                                        }
-                                    }
-                                    if (callResult.argumentErrors) {
-                                        if (usage.method === 'set') {
-                                            if (usage.setType &&
-                                                (0, types_1.isFunction)(boundMethodType) &&
-                                                boundMethodType.details.parameters.length >= 2 &&
-                                                !usage.setType.isIncomplete) {
-                                                const setterType = types_1.FunctionType.getEffectiveParameterType(boundMethodType, 1);
-                                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeIncompatible().format({
-                                                    destType: printType(setterType),
-                                                    sourceType: printType(usage.setType.type),
-                                                }));
-                                            }
-                                            else if ((0, types_1.isOverloadedFunction)(boundMethodType)) {
-                                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.noOverload().format({ name: accessMethodName }));
-                                            }
-                                        }
-                                        else {
-                                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.descriptorAccessCallFailed().format({
-                                                name: accessMethodName,
-                                                className: printType((0, typeUtils_1.convertToInstance)(accessMethod.classType)),
-                                            }));
-                                        }
-                                        isTypeValid = false;
-                                        return types_1.AnyType.create();
-                                    }
-                                    // For set or delete, always return Any.
-                                    return usage.method === 'get'
-                                        ? (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create()
-                                        : types_1.AnyType.create();
-                                }
-                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.descriptorAccessBindingFailed().format({
-                                    name: accessMethodName,
-                                    className: printType((0, typeUtils_1.convertToInstance)(accessMethod.classType)),
-                                }));
-                                isTypeValid = false;
-                                return undefined;
-                            });
-                            // Determine if we're calling __set__ on an asymmetric descriptor or property.
-                            if (usage.method === 'set' && (0, types_1.isClass)(accessMethod.classType)) {
-                                if (isAsymmetricDescriptorClass(accessMethod.classType)) {
-                                    isAsymmetricAccessor = true;
-                                }
-                            }
-                            if (returnType) {
-                                return returnType;
-                            }
-                        }
-                    }
-                }
+        if (usage.method === 'set' && (0, types_1.isClass)(methodClassType)) {
+            if (isAsymmetricDescriptorClass(methodClassType)) {
+                isAsymmetricAccessor = true;
             }
-            else if ((0, types_1.isFunction)(concreteSubtype) || (0, types_1.isOverloadedFunction)(concreteSubtype)) {
-                // Check for an attempt to overwrite a final method.
-                if (usage.method === 'set') {
-                    let isFinal = false;
-                    if ((0, types_1.isFunction)(concreteSubtype)) {
-                        isFinal = types_1.FunctionType.isFinal(concreteSubtype);
-                    }
-                    else {
-                        const impl = types_1.OverloadedFunctionType.getImplementation(concreteSubtype);
-                        if (impl) {
-                            isFinal = types_1.FunctionType.isFinal(impl);
-                        }
-                    }
-                    if (isFinal && memberInfo && (0, types_1.isClass)(memberInfo.classType)) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
-                            name: memberName,
-                            className: memberInfo.classType.details.name,
-                        }));
-                        isTypeValid = false;
-                        return undefined;
-                    }
-                }
-                // If this function is an instance member (e.g. a lambda that was
-                // assigned to an instance variable), don't perform any binding.
-                if (!isAccessedThroughObject || (memberInfo && !memberInfo.isInstanceMember)) {
-                    return bindFunctionToClassOrObjectWithErrors(classType, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, treatConstructorAsClassMember, selfType && (0, types_1.isClass)(selfType) ? types_1.ClassType.cloneIncludeSubclasses(selfType) : selfType);
-                }
+        }
+        if (!methodType) {
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.descriptorAccessBindingFailed().format({
+                name: accessMethodName,
+                className: printType((0, typeUtils_1.convertToInstance)(methodClassType)),
+            }));
+            return {
+                type: types_1.UnknownType.create(),
+                typeErrors: true,
+                isDescriptorApplied: true,
+                isAsymmetricAccessor,
+            };
+        }
+        // Simulate a call to the access method.
+        const argList = [];
+        // Provide "obj" argument.
+        argList.push({
+            argumentCategory: 0 /* Simple */,
+            typeResult: {
+                type: types_1.ClassType.isClassProperty(concreteMemberType)
+                    ? classType
+                    : isAccessedThroughObject
+                        ? selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType)
+                        : getNoneType(),
+            },
+        });
+        if (usage.method === 'get') {
+            // Provide "owner" argument.
+            argList.push({
+                argumentCategory: 0 /* Simple */,
+                typeResult: {
+                    type: isAccessedThroughObject ? types_1.ClassType.cloneAsInstantiable(classType) : classType,
+                },
+            });
+        }
+        else if (usage.method === 'set') {
+            // Provide "value" argument.
+            argList.push({
+                argumentCategory: 0 /* Simple */,
+                typeResult: {
+                    type: (_b = (_a = usage.setType) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create(),
+                    isIncomplete: !!((_c = usage.setType) === null || _c === void 0 ? void 0 : _c.isIncomplete),
+                },
+            });
+        }
+        // Suppress diagnostics for these method calls because they would be redundant.
+        const callResult = suppressDiagnostics(errorNode, () => {
+            return validateCallArguments(errorNode, argList, { type: methodType }, 
+            /* typeVarContext */ undefined, 
+            /* skipUnknownArgCheck */ true);
+        });
+        // Collect deprecation information associated with the member access method.
+        let deprecationInfo;
+        if (callResult.overloadsUsedForCall && callResult.overloadsUsedForCall.length >= 1) {
+            const overloadUsed = callResult.overloadsUsedForCall[0];
+            if (overloadUsed.details.deprecatedMessage) {
+                deprecationInfo = {
+                    deprecationMessage: overloadUsed.details.deprecatedMessage,
+                    accessType: types_1.ClassType.isPropertyClass(concreteMemberType) ? 'property' : 'descriptor',
+                    accessMethod: usage.method,
+                };
             }
-            if (usage.method === 'set') {
-                if (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.isClassVar()) {
-                    if (flags & 128 /* DisallowClassVarWrites */) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberSetClassVar().format({ name: memberName }));
-                        isTypeValid = false;
-                        return undefined;
-                    }
-                }
-                // Check for an attempt to overwrite a final member variable.
-                const finalVarTypeDecl = memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.getDeclarations().find((decl) => isFinalVariableDeclaration(decl));
-                if (finalVarTypeDecl && !ParseTreeUtils.isNodeContainedWithin(errorNode, finalVarTypeDecl.node)) {
-                    // If a Final instance variable is declared in the class body but is
-                    // being assigned within an __init__ method, it's allowed.
-                    const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(errorNode);
-                    if (!enclosingFunctionNode || enclosingFunctionNode.name.value !== '__init__') {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.finalReassigned().format({ name: memberName }));
-                        isTypeValid = false;
-                        return undefined;
-                    }
-                }
-                // Check for an attempt to overwrite an instance variable that is
-                // read-only (e.g. in a named tuple).
-                if ((memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.isInstanceMember) &&
-                    (0, types_1.isClass)(memberInfo.classType) &&
-                    types_1.ClassType.isReadOnlyInstanceVariables(memberInfo.classType)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.readOnlyAttribute().format({ name: memberName }));
-                    isTypeValid = false;
-                    return undefined;
-                }
-                let enforceTargetType = false;
-                if (memberInfo && memberInfo.symbol.hasTypedDeclarations()) {
-                    // If the member has a declared type, we will enforce it.
-                    enforceTargetType = true;
-                }
-                else {
-                    // If the member has no declared type, we will enforce it
-                    // if this assignment isn't within the enclosing class. If
-                    // it is within the enclosing class, the assignment is used
-                    // to infer the type of the member.
-                    if (memberInfo && !memberInfo.symbol.getDeclarations().some((decl) => decl.node === errorNode)) {
-                        enforceTargetType = true;
-                    }
-                }
-                if (enforceTargetType) {
-                    let effectiveType = subtype;
-                    // If the code is patching a method (defined on the class)
-                    // with an object-level function, strip the "self" parameter
-                    // off the original type. This is sometimes done for test
-                    // purposes to override standard behaviors of specific methods.
-                    if (isAccessedThroughObject) {
-                        if (!memberInfo.isInstanceMember && (0, types_1.isFunction)(concreteSubtype)) {
-                            if (types_1.FunctionType.isClassMethod(concreteSubtype) ||
-                                types_1.FunctionType.isInstanceMethod(concreteSubtype)) {
-                                effectiveType = types_1.FunctionType.clone(concreteSubtype, /* stripFirstParam */ true);
-                            }
-                        }
-                    }
-                    return effectiveType;
-                }
+        }
+        if (!callResult.argumentErrors) {
+            return {
+                // For set or delete, always return Any.
+                type: usage.method === 'get' ? (_d = callResult.returnType) !== null && _d !== void 0 ? _d : types_1.UnknownType.create() : types_1.AnyType.create(),
+                isDescriptorApplied: true,
+                isAsymmetricAccessor,
+                memberAccessDeprecationInfo: deprecationInfo,
+            };
+        }
+        // Errors were detected when evaluating the access method call.
+        if (usage.method === 'set') {
+            if (usage.setType &&
+                (0, types_1.isFunction)(methodType) &&
+                methodType.details.parameters.length >= 2 &&
+                !usage.setType.isIncomplete) {
+                const setterType = types_1.FunctionType.getEffectiveParameterType(methodType, 1);
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeIncompatible().format({
+                    destType: printType(setterType),
+                    sourceType: printType(usage.setType.type),
+                }));
             }
-            return subtype;
-        });
-        if (!isTypeValid) {
-            return undefined;
+            else if ((0, types_1.isOverloadedFunction)(methodType)) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.noOverload().format({ name: accessMethodName }));
+            }
+        }
+        else {
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.descriptorAccessCallFailed().format({
+                name: accessMethodName,
+                className: printType((0, typeUtils_1.convertToInstance)(methodClassType)),
+            }));
         }
-        return { type, isAsymmetricAccessor, memberAccessDeprecationInfo };
+        return {
+            type: types_1.UnknownType.create(),
+            typeErrors: true,
+            isDescriptorApplied: true,
+            isAsymmetricAccessor,
+            memberAccessDeprecationInfo: deprecationInfo,
+        };
+    }
+    function bindMethodForMemberAccess(type, concreteType, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount = 0) {
+        // Check for an attempt to overwrite a final method.
+        if (usage.method === 'set') {
+            const impl = (0, types_1.isFunction)(concreteType)
+                ? concreteType
+                : types_1.OverloadedFunctionType.getImplementation(concreteType);
+            if (impl && types_1.FunctionType.isFinal(impl) && memberInfo && (0, types_1.isClass)(memberInfo.classType)) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
+                    name: memberName,
+                    className: memberInfo.classType.details.name,
+                }));
+                return { type: types_1.UnknownType.create(), typeErrors: true };
+            }
+        }
+        // If this function is an instance member (e.g. a lambda that was
+        // assigned to an instance variable), don't perform any binding.
+        if (types_1.TypeBase.isInstance(classType)) {
+            if (!memberInfo || memberInfo.isInstanceMember) {
+                return { type: type };
+            }
+        }
+        const boundType = bindFunctionToClassOrObject(classType, concreteType, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, (flags & 256 /* TreatConstructorAsClassMethod */) !== 0, selfType && (0, types_1.isClass)(selfType) ? types_1.ClassType.cloneIncludeSubclasses(selfType) : selfType, diag, recursionCount);
+        return { type: boundType !== null && boundType !== void 0 ? boundType : types_1.UnknownType.create(), typeErrors: !boundType };
     }
     function isAsymmetricDescriptorClass(classType) {
         var _a;
@@ -4276,11 +4202,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return isAsymmetric;
     }
     // Applies the __getattr__, __setattr__ or __delattr__ method if present.
-    function applyAttributeAccessOverride(classType, errorNode, usage, memberName, selfType) {
+    // If it's not applicable, returns undefined.
+    function applyAttributeAccessOverride(errorNode, classType, usage, memberName, selfType) {
         var _a, _b, _c, _d, _e;
         const getAttributeAccessMember = (name) => {
             var _a;
-            return (_a = getTypeOfObjectMember(errorNode, classType, name, { method: 'get' }, 
+            return (_a = getTypeOfBoundMember(errorNode, classType, name, 
+            /* usage */ undefined, 
             /* diag */ undefined, 16 /* SkipInstanceMembers */ |
                 4 /* SkipObjectBaseClass */ |
                 512 /* SkipAttributeAccessOverride */, selfType)) === null || _a === void 0 ? void 0 : _a.type;
@@ -4299,20 +4227,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!accessMemberType) {
             return undefined;
         }
-        let nameLiteralType = types_1.AnyType.create();
-        if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
-            nameLiteralType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName);
-        }
-        const argList = [
-            {
-                // Provide "name" argument.
-                argumentCategory: 0 /* Simple */,
-                typeResult: { type: nameLiteralType },
+        const argList = [];
+        // Provide "name" argument.
+        argList.push({
+            argumentCategory: 0 /* Simple */,
+            typeResult: {
+                type: strClassType && (0, types_1.isInstantiableClass)(strClassType)
+                    ? types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName)
+                    : types_1.AnyType.create(),
             },
-        ];
+        });
         if (usage.method === 'set') {
+            // Provide "value" argument.
             argList.push({
-                // Provide "value" argument.
                 argumentCategory: 0 /* Simple */,
                 typeResult: {
                     type: (_c = (_b = usage.setType) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
@@ -4321,20 +4248,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
         }
         if (!(0, types_1.isFunction)(accessMemberType) && !(0, types_1.isOverloadedFunction)(accessMemberType)) {
-            // TODO - need to handle and report this error.
+            if ((0, types_1.isAnyOrUnknown)(accessMemberType)) {
+                return { type: accessMemberType };
+            }
+            // TODO - emit an error for this condition.
             return undefined;
         }
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(accessMemberType));
         const callResult = validateCallArguments(errorNode, argList, { type: accessMemberType }, typeVarContext, 
         /* skipUnknownArgCheck */ true);
-        // TODO - need to handle and report errors when validating call to
-        // attribute access method.
         let isAsymmetricAccessor = false;
         if (usage.method === 'set') {
             isAsymmetricAccessor = isClassWithAsymmetricAttributeAccessor(classType);
         }
         return {
             type: (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create(),
+            typeErrors: callResult.argumentErrors,
             isAsymmetricAccessor,
         };
     }
@@ -4545,10 +4474,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeParameters.forEach((param, index) => {
             if (param.details.isParamSpec && index < typeArgs.length) {
                 const typeArgType = typeArgs[index].type;
-                if (typeArgs[index].typeList) {
+                const typeList = typeArgs[index].typeList;
+                if (typeList) {
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */);
                     types_1.TypeBase.setSpecialForm(functionType);
-                    typeArgs[index].typeList.forEach((paramType, paramIndex) => {
+                    typeList.forEach((paramType, paramIndex) => {
                         types_1.FunctionType.addParameter(functionType, {
                             category: 0 /* Simple */,
                             name: `__p${paramIndex}`,
@@ -4663,7 +4593,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
-            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeAliasIsPep695Syntax, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
+            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, !!baseTypeResult.type.details.recursiveTypeAliasIsPep695Syntax, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
             return { type };
         }
         let isIncomplete = baseTypeResult.isIncomplete;
@@ -4692,9 +4622,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, types_1.isInstantiableClass)(concreteSubtype.details.effectiveMetaclass) &&
                     !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta']) &&
                     (flags & 128 /* ExpectingInstantiableType */) === 0) {
-                    const itemMethodType = getTypeOfObjectMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
-                    /* usage */ undefined, 
-                    /* diag */ undefined, 512 /* SkipAttributeAccessOverride */);
+                    const itemMethodType = getBoundMagicMethod(concreteSubtype, getIndexAccessMagicMethodName(usage));
                     if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0) {
                         // If the class doesn't derive from Generic, a type argument should not be allowed.
                         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({
@@ -4920,7 +4848,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfIndexedObjectOrClass(node, baseType, usage) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         // Handle index operations for TypedDict classes specially.
         if ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isTypedDictClass(baseType)) {
             const typeFromTypedDict = (0, typedDicts_1.getTypeOfIndexedTypedDict)(evaluatorInterface, node, baseType, usage);
@@ -4929,9 +4857,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const magicMethodName = getIndexAccessMagicMethodName(usage);
-        const itemMethodType = (_a = getTypeOfObjectMember(node, baseType, magicMethodName, 
-        /* usage */ undefined, 
-        /* diag */ undefined, 512 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
+        const itemMethodType = getBoundMagicMethod(baseType, magicMethodName);
         if (!itemMethodType) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
@@ -5060,7 +4986,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             },
         ];
         if (usage.method === 'set') {
-            let setType = (_c = (_b = usage.setType) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : types_1.AnyType.create();
+            let setType = (_b = (_a = usage.setType) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
             // Expand constrained type variables.
             if ((0, types_1.isTypeVar)(setType) && setType.details.constraints.length > 0) {
                 const conditionFilter = (0, types_1.isClassInstance)(baseType) ? baseType.condition : undefined;
@@ -5071,7 +4997,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argumentCategory: 0 /* Simple */,
                 typeResult: {
                     type: setType,
-                    isIncomplete: !!((_d = usage.setType) === null || _d === void 0 ? void 0 : _d.isIncomplete),
+                    isIncomplete: !!((_c = usage.setType) === null || _c === void 0 ? void 0 : _c.isIncomplete),
                 },
             });
         }
@@ -5103,7 +5029,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((0, types_1.isClassInstance)(positionalIndexType)) {
                         const altArgList = [...argList];
                         altArgList[0] = { ...altArgList[0] };
-                        const indexMethod = getTypeOfObjectMember(node, positionalIndexType, '__index__');
+                        const indexMethod = getBoundMagicMethod(positionalIndexType, '__index__');
                         if (indexMethod) {
                             const intType = getBuiltInObject(node, 'int');
                             if ((0, types_1.isClassInstance)(intType)) {
@@ -5121,7 +5047,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         callResult = validateCallArguments(node, argList, { type: itemMethodType });
         return {
-            type: (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create(),
+            type: (_d = callResult.returnType) !== null && _d !== void 0 ? _d : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
@@ -5807,7 +5733,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (bindToType && implicitBindToType) {
-                bindToType = (0, typeUtils_1.addConditionToType)(bindToType, (0, typeUtils_1.getTypeCondition)(implicitBindToType));
+                const typeCondition = (0, typeUtils_1.getTypeCondition)(implicitBindToType);
+                if (typeCondition) {
+                    bindToType = (0, typeUtils_1.addConditionToType)(bindToType, typeCondition);
+                }
+                else if ((0, types_1.isClass)(implicitBindToType)) {
+                    bindToType = implicitBindToType;
+                }
             }
         }
         // Determine whether super() should return an instance of the class or
@@ -5830,9 +5762,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Python docs indicate that super() isn't valid for
         // operations other than member accesses or attribute lookups.
         const parentNode = node.parent;
-        if (parentNode.nodeType === 35 /* MemberAccess */) {
+        if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.nodeType) === 35 /* MemberAccess */) {
             const memberName = parentNode.memberName.value;
-            const effectiveTargetClass = (0, types_1.isClass)(targetClassType) ? targetClassType : undefined;
+            let effectiveTargetClass = (0, types_1.isClass)(targetClassType) ? targetClassType : undefined;
+            // If the bind-to type is a protocol, don't use the effective target class.
+            // This pattern is used for mixins, where the mixin type is a protocol class
+            // that is used to decorate the "self" or "cls" parameter.
+            if (bindToType &&
+                types_1.ClassType.isProtocolClass(bindToType) &&
+                effectiveTargetClass &&
+                !types_1.ClassType.isSameGenericClass(bindToType, effectiveTargetClass)) {
+                effectiveTargetClass = undefined;
+            }
             const lookupResults = bindToType
                 ? (0, typeUtils_1.lookUpClassMember)(bindToType, memberName, 0 /* Default */, effectiveTargetClass)
                 : undefined;
@@ -6563,7 +6504,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const result = {
                     returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ true),
                 };
-                const initTypeResult = getTypeOfObjectMember(errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), '__init__');
+                const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 
+                /* skipObjectBase */ false);
                 if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
                     validateOverloadedFunctionArguments(errorNode, argList, { type: initTypeResult.type }, 
                     /* typeVarContext */ undefined, skipUnknownArgCheck, 
@@ -6664,18 +6606,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { returnType, overloadsUsedForCall, argumentErrors, isTypeIncomplete };
     }
     function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
-        var _a, _b;
-        const memberType = (_a = getTypeOfObjectMember(errorNode, expandedCallType, '__call__', 
+        var _a;
+        const callMethodResult = getTypeOfBoundMember(errorNode, expandedCallType, '__call__', 
         /* usage */ undefined, 
-        /* diag */ undefined, 512 /* SkipAttributeAccessOverride */ | 16 /* SkipInstanceMembers */)) === null || _a === void 0 ? void 0 : _a.type;
-        if (!memberType) {
+        /* diag */ undefined, 16 /* SkipInstanceMembers */ | 512 /* SkipAttributeAccessOverride */, 
+        /* selfType */ undefined, recursionCount);
+        const callMethodType = callMethodResult === null || callMethodResult === void 0 ? void 0 : callMethodResult.type;
+        if (!callMethodType) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
                 type: printType(expandedCallType),
             }), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
-        const callResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
-        let returnType = (_b = callResult.returnType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+        const callResult = validateCallArguments(errorNode, argList, { type: callMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+        let returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         if ((0, types_1.isTypeVar)(unexpandedCallType) &&
             types_1.TypeBase.isInstantiable(unexpandedCallType) &&
             (0, types_1.isClass)(expandedCallType) &&
@@ -6755,7 +6699,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const paramDetails = (0, parameterUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
@@ -6867,9 +6811,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let paramIndex = 0;
         while (argIndex < positionalArgCount) {
             if (argIndex < positionalOnlyLimitIndex && argList[argIndex].name) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(argList[argIndex].name);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argPositional(), argList[argIndex].name);
-                reportedArgError = true;
+                const nameNode = argList[argIndex].name;
+                if (nameNode) {
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(nameNode);
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argPositional(), nameNode);
+                    reportedArgError = true;
+                }
             }
             const remainingArgCount = positionalArgCount - argIndex;
             const remainingParamCount = positionParamLimitIndex - paramIndex - 1;
@@ -6980,9 +6927,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     listElementType = undefined;
                 }
                 else {
-                    listElementType =
-                        (_e = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
-                        /* isAsync */ false, argList[argIndex].valueExpression)) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
+                    const valueExpr = argList[argIndex].valueExpression;
+                    const iteratorType = valueExpr
+                        ? (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
+                        /* isAsync */ false, valueExpr)) === null || _d === void 0 ? void 0 : _d.type
+                        : undefined;
+                    listElementType = iteratorType !== null && iteratorType !== void 0 ? iteratorType : types_1.UnknownType.create();
                     if (paramDetails.params[paramIndex].param.category !== 1 /* ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
@@ -7014,7 +6964,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramType,
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: funcArg,
-                            errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
+                            errorNode: (_e = argList[argIndex].valueExpression) !== null && _e !== void 0 ? _e : errorNode,
                             paramName,
                             isParamNameSynthesized: paramDetails.params[paramIndex].param.isNameSynthesized,
                             mapsToVarArgList: isParamVariadic && remainingArgCount > remainingParamCount,
@@ -7317,7 +7267,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
+                                    errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 trySetActive(argList[argIndex], paramDetails.params[paramInfoIndex].param);
@@ -7333,7 +7283,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 paramType,
                                 requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                 argument: argList[argIndex],
-                                errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
                                 paramName: paramNameValue,
                             });
                             // Remember that this parameter has already received a value.
@@ -7382,7 +7332,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
                                     argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
-                                    errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
+                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
                                 });
                             }
                         }
@@ -8901,13 +8851,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let magicMethodSupported = true;
         // Create a helper lambda for object subtypes.
         const handleSubtype = (subtype) => {
-            var _a;
             let magicMethodType;
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isClass)(concreteSubtype)) {
-                magicMethodType = (_a = getTypeOfObjectMember(errorNode, concreteSubtype, methodName, 
-                /* usage */ undefined, 
-                /* diag */ undefined, 16 /* SkipInstanceMembers */ | 512 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
+                magicMethodType = getBoundMagicMethod(concreteSubtype, methodName, subtype);
             }
             if (magicMethodType) {
                 const functionArgs = argList.map((arg) => {
@@ -8917,16 +8864,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     };
                 });
                 let callResult;
-                useSpeculativeMode(errorNode, () => {
-                    callResult = validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
+                callResult = useSpeculativeMode(errorNode, () => {
+                    (0, debug_1.assert)(magicMethodType !== undefined);
+                    return validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
                     /* typeVarContext */ undefined, 
                     /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 // If there were errors with the expected type, try
                 // to evaluate without the expected type.
                 if (callResult.argumentErrors && inferenceContext) {
-                    useSpeculativeMode(errorNode, () => {
-                        callResult = validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
+                    callResult = useSpeculativeMode(errorNode, () => {
+                        (0, debug_1.assert)(magicMethodType !== undefined);
+                        return validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
                         /* typeVarContext */ undefined, 
                         /* skipUnknownArgCheck */ true);
                     });
@@ -9569,7 +9518,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     expectedFunctionTypes.push(subtype);
                 }
                 if ((0, types_1.isClassInstance)(subtype)) {
-                    const boundMethod = getBoundMethod(subtype, '__call__');
+                    const boundMethod = getBoundMagicMethod(subtype, '__call__');
                     if (boundMethod && (0, types_1.isFunction)(boundMethod)) {
                         expectedFunctionTypes.push(boundMethod);
                     }
@@ -10452,6 +10401,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 let reportedUnpackedError = false;
                 // Verify that we didn't receive any inappropriate types.
                 typeArgs.forEach((typeArg, index) => {
+                    (0, debug_1.assert)(typeArgs !== undefined);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         if (!isTupleTypeParam) {
                             if (!allowParamSpec) {
@@ -10638,6 +10588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // with this type alias.
             typeParameters = [];
             (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                (0, debug_1.assert)(typeParameters !== undefined);
                 (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(subtype));
             });
             // Don't include any synthesized type variables.
@@ -10654,6 +10605,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Validate the default types for all type parameters.
         typeParameters.forEach((typeParam, index) => {
             var _a;
+            (0, debug_1.assert)(typeParameters !== undefined);
             let bestErrorNode = errorNode;
             if (typeParamNodes && index < typeParamNodes.length) {
                 bestErrorNode = (_a = typeParamNodes[index].defaultExpression) !== null && _a !== void 0 ? _a : typeParamNodes[index].name;
@@ -10934,6 +10886,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // If this is a type alias, record its name based on the assignment target.
                         rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression, 
                         /* isPep695Syntax */ false);
+                        (0, debug_1.assert)(typeAliasTypeVar !== undefined);
                         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
                             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
                                 name: typeAliasNameNode.value,
@@ -11650,6 +11603,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (p.details.isVariadic) {
                     return p;
                 }
+                (0, debug_1.assert)(objectType !== undefined);
                 return i === paramIndex ? objectType : dummyTypeObject;
             });
             // Replace all type arguments with a dummy type except for the
@@ -11818,6 +11772,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         computeEffectiveMetaclass(type, errorNode);
     }
     function validateInitSubclassArgs(node, classType) {
+        var _a, _b;
         // Collect arguments that will be passed to the `__init_subclass__`
         // method described in PEP 487 and validate it.
         const argList = [];
@@ -11831,72 +11786,91 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
             }
         });
-        const errorNode = argList.length > 0 ? argList[0].node.name : node.name;
-        const initSubclassMethodInfo = getTypeOfObjectMember(errorNode, classType, '__init_subclass__', { method: 'get' }, 
-        /* diag */ undefined, 32 /* SkipClassMembers */ |
-            4 /* SkipObjectBaseClass */ |
-            1 /* SkipOriginalClass */ |
-            512 /* SkipAttributeAccessOverride */);
-        if (initSubclassMethodInfo) {
-            const initSubclassMethodType = initSubclassMethodInfo.type;
-            if (initSubclassMethodType) {
-                validateCallArguments(errorNode, argList, { type: initSubclassMethodType }, 
-                /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()));
-            }
-        }
-        else if (classType.details.effectiveMetaclass && (0, types_1.isClass)(classType.details.effectiveMetaclass)) {
+        const errorNode = argList.length > 0 ? (_b = (_a = argList[0].node) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : node.name : node.name;
+        let newMethodMember;
+        if (classType.details.effectiveMetaclass && (0, types_1.isClass)(classType.details.effectiveMetaclass)) {
             // See if the metaclass has a `__new__` method that accepts keyword parameters.
-            const newMethodMember = (0, typeUtils_1.lookUpClassMember)(classType.details.effectiveMetaclass, '__new__', 8 /* SkipTypeBaseClass */);
-            if (newMethodMember) {
-                const newMethodType = getTypeOfMember(newMethodMember);
-                if ((0, types_1.isFunction)(newMethodType)) {
-                    const paramListDetails = (0, parameterUtils_1.getParameterListDetails)(newMethodType);
-                    if (paramListDetails.firstKeywordOnlyIndex !== undefined) {
-                        // Build a map of the keyword-only parameters.
-                        const paramMap = new Map();
-                        for (let i = paramListDetails.firstKeywordOnlyIndex; i < paramListDetails.params.length; i++) {
-                            const paramInfo = paramListDetails.params[i];
-                            if (paramInfo.param.category === 0 /* Simple */ && paramInfo.param.name) {
-                                paramMap.set(paramInfo.param.name, i);
-                            }
+            newMethodMember = (0, typeUtils_1.lookUpClassMember)(classType.details.effectiveMetaclass, '__new__', 8 /* SkipTypeBaseClass */);
+        }
+        if (newMethodMember) {
+            const newMethodType = getTypeOfMember(newMethodMember);
+            if ((0, types_1.isFunction)(newMethodType)) {
+                const paramListDetails = (0, parameterUtils_1.getParameterListDetails)(newMethodType);
+                if (paramListDetails.firstKeywordOnlyIndex !== undefined) {
+                    // Build a map of the keyword-only parameters.
+                    const paramMap = new Map();
+                    for (let i = paramListDetails.firstKeywordOnlyIndex; i < paramListDetails.params.length; i++) {
+                        const paramInfo = paramListDetails.params[i];
+                        if (paramInfo.param.category === 0 /* Simple */ && paramInfo.param.name) {
+                            paramMap.set(paramInfo.param.name, i);
                         }
-                        argList.forEach((arg) => {
-                            var _a, _b, _c;
-                            const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
-                            if (arg.argumentCategory === 0 /* Simple */ && arg.name) {
-                                const paramIndex = (_a = paramMap.get(arg.name.value)) !== null && _a !== void 0 ? _a : paramListDetails.kwargsIndex;
-                                if (paramIndex !== undefined) {
-                                    const paramInfo = paramListDetails.params[paramIndex];
-                                    const argParam = {
-                                        paramCategory: paramInfo.param.category,
-                                        paramType: types_1.FunctionType.getEffectiveParameterType(newMethodType, paramInfo.index),
-                                        requiresTypeVarMatching: false,
-                                        argument: arg,
-                                        errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
-                                    };
-                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, { skipUnknownArgCheck: true, skipOverloadArg: true });
-                                    paramMap.delete(arg.name.value);
-                                }
-                                else {
-                                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: arg.name.value }), (_c = arg.name) !== null && _c !== void 0 ? _c : errorNode);
-                                }
+                    }
+                    argList.forEach((arg) => {
+                        var _a, _b, _c;
+                        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+                        if (arg.argumentCategory === 0 /* Simple */ && arg.name) {
+                            const paramIndex = (_a = paramMap.get(arg.name.value)) !== null && _a !== void 0 ? _a : paramListDetails.kwargsIndex;
+                            if (paramIndex !== undefined) {
+                                const paramInfo = paramListDetails.params[paramIndex];
+                                const argParam = {
+                                    paramCategory: paramInfo.param.category,
+                                    paramType: types_1.FunctionType.getEffectiveParameterType(newMethodType, paramInfo.index),
+                                    requiresTypeVarMatching: false,
+                                    argument: arg,
+                                    errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
+                                };
+                                validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, { skipUnknownArgCheck: true, skipOverloadArg: true });
+                                paramMap.delete(arg.name.value);
                             }
-                        });
-                        // See if we have any remaining unmatched parameters without
-                        // default values.
-                        const unassignedParams = [];
-                        paramMap.forEach((index, paramName) => {
-                            const paramInfo = paramListDetails.params[index];
-                            if (!paramInfo.param.hasDefault) {
-                                unassignedParams.push(paramName);
+                            else {
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: arg.name.value }), (_c = arg.name) !== null && _c !== void 0 ? _c : errorNode);
                             }
-                        });
-                        if (unassignedParams.length > 0) {
-                            const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
-                                ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
-                                : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                        }
+                    });
+                    // See if we have any remaining unmatched parameters without
+                    // default values.
+                    const unassignedParams = [];
+                    paramMap.forEach((index, paramName) => {
+                        const paramInfo = paramListDetails.params[index];
+                        if (!paramInfo.param.hasDefault) {
+                            unassignedParams.push(paramName);
+                        }
+                    });
+                    if (unassignedParams.length > 0) {
+                        const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
+                            ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
+                            : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                    }
+                }
+            }
+        }
+        else {
+            // If there was no custom metaclass __new__ method, see if there is an __init_subclass__
+            // method present somewhere in the class hierarchy.
+            const initSubclassMethodInfo = getTypeOfBoundMember(errorNode, classType, '__init_subclass__', 
+            /* usage */ undefined, 
+            /* diag */ undefined, 32 /* SkipClassMembers */ |
+                1 /* SkipOriginalClass */ |
+                512 /* SkipAttributeAccessOverride */);
+            if (initSubclassMethodInfo) {
+                const initSubclassMethodType = initSubclassMethodInfo.type;
+                if (initSubclassMethodType && initSubclassMethodInfo.classType) {
+                    const callResult = validateCallArguments(errorNode, argList, { type: initSubclassMethodType }, 
+                    /* typeVarContext */ undefined, 
+                    /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()));
+                    if (callResult.argumentErrors) {
+                        const diag = addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initSubclassCallFailed(), node.name);
+                        const initSubclassFunction = (0, types_1.isOverloadedFunction)(initSubclassMethodType)
+                            ? types_1.OverloadedFunctionType.getOverloads(initSubclassMethodType)[0]
+                            : initSubclassMethodType;
+                        const initSubclassDecl = (0, types_1.isFunction)(initSubclassFunction)
+                            ? initSubclassFunction.details.declaration
+                            : undefined;
+                        if (diag && initSubclassDecl) {
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.initSubclassLocation().format({
+                                name: printType((0, typeUtils_1.convertToInstance)(initSubclassMethodInfo.classType)),
+                            }), initSubclassDecl.path, initSubclassDecl.range);
                         }
                     }
                 }
@@ -12060,7 +12034,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // accumulate the list of type parameters upfront.
         const typeParametersSeen = [];
         if (node.typeParameters) {
-            functionType.details.typeParameters = evaluateTypeParameterList(node.typeParameters);
+            functionType.details.typeParameters = evaluateTypeParameterList(node.typeParameters).map((typeParam) => (0, typeUtils_1.convertToInstance)(typeParam));
         }
         else {
             functionType.details.typeParameters = typeParametersSeen;
@@ -13945,6 +13919,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else {
                     // Avoid emitting this error for a partially-constructed class.
                     if (!(0, types_1.isClassInstance)(typeArgType) || !types_1.ClassType.isPartiallyEvaluated(typeArgType)) {
+                        (0, debug_1.assert)(typeArgs !== undefined);
                         const fileInfo = AnalyzerNodeInfo.getFileInfo(typeArgs[index].node);
                         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarAssignmentMismatch().format({
                             type: printType(typeArgType),
@@ -13986,6 +13961,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // If there was no defined type provided, there should always
         // be a value expression from which we can retrieve the type.
+        (0, debug_1.assert)(arg.valueExpression !== undefined);
         return getTypeOfExpressionExpectingType(arg.valueExpression, options);
     }
     function getTypeOfExpressionExpectingType(node, options) {
@@ -14371,8 +14347,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         });
                     }
                     else if ((0, types_1.isInstantiableClass)(baseType)) {
-                        const initMethodType = (_b = getTypeOfObjectMember(argNode.parent.leftExpression, types_1.ClassType.cloneAsInstance(baseType), '__init__', { method: 'get' }, 
-                        /* diag */ undefined, 4 /* SkipObjectBaseClass */)) === null || _b === void 0 ? void 0 : _b.type;
+                        const initMethodType = (_b = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, argNode.parent.leftExpression, types_1.ClassType.cloneAsInstance(baseType))) === null || _b === void 0 ? void 0 : _b.type;
                         if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
                             const paramDecl = getDeclarationFromFunctionNamedParameter(initMethodType, paramName);
                             if (paramDecl) {
@@ -14754,6 +14729,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the resolved declaration had no defined type, use the
         // inferred type for this node.
         if (resolvedDecl.type === 2 /* Parameter */) {
+            (0, debug_1.assert)(resolvedDecl.node.name !== undefined);
             return (_b = evaluateTypeForSubnode(resolvedDecl.node.name, () => {
                 evaluateTypeOfParameter(resolvedDecl.node);
             })) === null || _b === void 0 ? void 0 : _b.type;
@@ -14772,8 +14748,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // See if this is an enum member. If so, we need to handle it as a special case.
                 const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, resolvedDecl.node, () => {
                     var _a, _b;
-                    return ((_b = (_a = evaluateTypeForSubnode(resolvedDecl.inferredTypeSource, () => {
-                        evaluateTypesForStatement(resolvedDecl.inferredTypeSource);
+                    (0, debug_1.assert)(resolvedDecl.inferredTypeSource !== undefined);
+                    const inferredTypeSource = resolvedDecl.inferredTypeSource;
+                    return ((_b = (_a = evaluateTypeForSubnode(inferredTypeSource, () => {
+                        evaluateTypesForStatement(inferredTypeSource);
                     })) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
                 });
                 if (enumMemberType) {
@@ -15544,8 +15522,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // derive from the source. We also need to use this path if we're
         // testing to see if the metaclass matches the protocol.
         if (types_1.ClassType.isProtocolClass(destType) && !isDerivedFrom) {
-            if (!(0, protocols_1.assignClassToProtocol)(evaluatorInterface, destType, srcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, 
-            /* treatSourceAsInstantiable */ false, recursionCount)) {
+            if (!(0, protocols_1.assignClassToProtocol)(evaluatorInterface, destType, types_1.ClassType.cloneAsInstance(srcType), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolIncompatible().format({
                     sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
                     destType: printType((0, typeUtils_1.convertToInstance)(destType)),
@@ -15797,9 +15774,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         for (let ancestorIndex = inheritanceChain.length - 1; ancestorIndex >= 0; ancestorIndex--) {
             const ancestorType = inheritanceChain[ancestorIndex];
             // If we've hit an "unknown", all bets are off, and we need to assume
-            // that the type is assignable.
+            // that the type is assignable. If the destType is marked "@final",
+            // we should be able to assume that it's not assignable, but we can't do
+            // this in the general case because it breaks assumptions with the
+            // NotImplemented symbol exported by typeshed's builtins.pyi. Instead,
+            // we'll special-case only None.
             if ((0, types_1.isUnknown)(ancestorType)) {
-                return true;
+                return !(0, typeUtils_1.isNoneTypeClass)(destType);
             }
             // If this isn't the first time through the loop, specialize
             // for the next ancestor in the chain.
@@ -15852,24 +15833,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const srcTypeArgs = curSrcType.typeArguments;
             for (let i = 0; i < destType.details.typeParameters.length; i++) {
                 const typeArgType = i < srcTypeArgs.length ? srcTypeArgs[i] : types_1.UnknownType.create();
-                destTypeVarContext.setTypeVarType(destType.details.typeParameters[i], 
-                /* narrowBound */ undefined, 
-                /* narrowBoundNoLiterals */ undefined, typeArgType);
+                const typeParam = destType.details.typeParameters[i];
+                const variance = types_1.TypeVarType.getVariance(typeParam);
+                (0, constraintSolver_1.updateTypeVarType)(evaluatorInterface, destTypeVarContext, typeParam, variance !== 4 /* Contravariant */ ? typeArgType : undefined, variance !== 3 /* Covariant */ ? typeArgType : undefined, 
+                /* forceRetainLiterals */ true);
             }
         }
         return true;
     }
     function getGetterTypeFromProperty(propertyClass, inferTypeIfNeeded) {
-        var _a;
         if (!types_1.ClassType.isPropertyClass(propertyClass)) {
             return undefined;
         }
-        const fgetSymbol = propertyClass.details.fields.get('fget');
-        if (fgetSymbol) {
-            const fgetType = (_a = getDeclaredTypeOfSymbol(fgetSymbol)) === null || _a === void 0 ? void 0 : _a.type;
-            if (fgetType && (0, types_1.isFunction)(fgetType)) {
-                return getFunctionEffectiveReturnType(fgetType, /* args */ undefined, inferTypeIfNeeded);
-            }
+        if (propertyClass.fgetFunction) {
+            return getFunctionEffectiveReturnType(propertyClass.fgetFunction, /* args */ undefined, inferTypeIfNeeded);
         }
         return undefined;
     }
@@ -16390,8 +16367,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If the destType is an instantiation of a Protocol,
                 // see if the class type itself satisfies the protocol.
                 if (types_1.ClassType.isProtocolClass(destType)) {
-                    return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, 
-                    /* treatSourceAsInstantiable */ true, recursionCount);
+                    return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
                 }
                 // Determine if the metaclass can be assigned to the object.
                 const metaclass = concreteSrcType.details.effectiveMetaclass;
@@ -16415,14 +16391,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isFunction)(destType)) {
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClassInstance)(concreteSrcType)) {
-                const boundMethod = getBoundMethod(concreteSrcType, '__call__', recursionCount);
+                const boundMethod = getBoundMagicMethod(concreteSrcType, '__call__', 
+                /* selfType */ undefined, recursionCount);
                 if (boundMethod) {
                     concreteSrcType = (0, typeUtils_1.removeParamSpecVariadicsFromSignature)(boundMethod);
                 }
             }
             // If it's a class, use the constructor for type compatibility checking.
             if ((0, types_1.isInstantiableClass)(concreteSrcType) && concreteSrcType.literalValue === undefined) {
-                const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, concreteSrcType, recursionCount);
+                const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, concreteSrcType, (0, types_1.isTypeVar)(srcType) ? (0, typeUtils_1.convertToInstance)(srcType) : undefined, recursionCount);
                 if (constructor) {
                     concreteSrcType = constructor;
                 }
@@ -16517,8 +16494,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Are we trying to assign None to a protocol?
         if ((0, typeUtils_1.isNoneInstance)(srcType) && (0, types_1.isClassInstance)(destType) && types_1.ClassType.isProtocolClass(destType)) {
             if (noneClassType && (0, types_1.isInstantiableClass)(noneClassType)) {
-                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), noneClassType, diag, destTypeVarContext, srcTypeVarContext, flags, 
-                /* treatSourceAsInstantiable */ false, recursionCount);
+                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(noneClassType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
             }
         }
         if ((0, typeUtils_1.isNoneInstance)(destType)) {
@@ -16907,7 +16883,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const boundMethod = getBoundMethod(objType, '__call__', recursionCount);
+        const boundMethod = getBoundMagicMethod(objType, '__call__', /* selfType */ undefined, recursionCount);
         if (boundMethod) {
             return (0, typeUtils_1.removeParamSpecVariadicsFromSignature)(boundMethod);
         }
@@ -16993,7 +16969,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (srcDetails.params.length < destDetails.argsIndex) {
             return;
         }
-        let srcLastToPackIndex = srcDetails.params.findIndex((p, i) => i >= destDetails.argsIndex && p.source === parameterUtils_1.ParameterSource.KeywordOnly);
+        let srcLastToPackIndex = srcDetails.params.findIndex((p, i) => {
+            (0, debug_1.assert)(destDetails.argsIndex !== undefined);
+            return i >= destDetails.argsIndex && p.source === parameterUtils_1.ParameterSource.KeywordOnly;
+        });
         if (srcLastToPackIndex < 0) {
             srcLastToPackIndex = srcDetails.params.length;
         }
@@ -17655,7 +17634,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 matchIndex = possibleMatchIndex;
             }
             if (matchIndex < 0) {
-                continue;
+                break;
             }
             if (matchIndex < previousMatchIndex) {
                 diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadOrder());
@@ -18109,14 +18088,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return methodList;
     }
-    function bindFunctionToClassOrObjectWithErrors(baseType, memberType, memberClass, errorNode, treatConstructorAsClassMember = false, selfType) {
-        const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
-        const result = bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember, selfType, 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 treatConstructorAsClassMember is true, the function is
@@ -18135,9 +18106,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
                     return functionType;
                 }
-                const baseObj = (0, types_1.isInstantiableClass)(baseType)
-                    ? types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType))
-                    : baseType;
+                const baseObj = (0, types_1.isClassInstance)(baseType)
+                    ? baseType
+                    : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType));
                 return partiallySpecializeFunctionForBoundClassOrObject(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, 
                 /* stripFirstParam */ (0, types_1.isClassInstance)(baseType));
             }
@@ -18444,8 +18415,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getBestOverloadForArguments,
         getBuiltInType,
         getTypeOfMember,
-        getTypeOfObjectMember,
-        getBoundMethod,
+        getTypeOfBoundMember,
+        getBoundMagicMethod,
         getTypeOfMagicMethodCall,
         bindFunctionToClassOrObject,
         getCallSignatureInfo,