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

package/dist/analyzer/typeEvaluator.js

@@ -178,6 +178,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let deferredClassCompletions = [];
     let cancellationToken;
     let isBasicTypesInitialized = false;
+    let noneClassType;
     let noneType;
     let objectType;
     let typeClassType;
@@ -374,6 +375,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // type of surrounding statements to be evaluated.
     function getType(node) {
         var _a, _b;
+        initializedBasicTypes(node);
         let type = (_a = evaluateTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
         })) === null || _a === void 0 ? void 0 : _a.type;
@@ -447,6 +449,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function initializedBasicTypes(node) {
+        var _a;
         if (!isBasicTypesInitialized) {
             // Some of these types have cyclical dependencies on each other,
             // so don't re-enter this block once we start executing it.
@@ -457,7 +460,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Initialize and cache "Collection" to break a cyclical dependency
             // that occurs when resolving tuple below.
             getTypingType(node, 'Collection');
-            noneType = getTypeshedType(node, 'NoneType') || types_1.AnyType.create();
+            noneClassType = (_a = getTypeshedType(node, 'NoneType')) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+            noneType = (0, types_1.isInstantiableClass)(noneClassType)
+                ? types_1.ClassType.cloneAsInstance(noneClassType)
+                : types_1.UnknownType.create();
             tupleClassType = getBuiltInType(node, 'tuple');
             boolClassType = getBuiltInType(node, 'bool');
             intClassType = getBuiltInType(node, 'int');
@@ -1079,20 +1085,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 0 /* Unbound */:
             case 1 /* Unknown */:
             case 2 /* Any */:
-            case 4 /* Never */:
-            case 3 /* None */: {
+            case 3 /* Never */: {
                 return true;
             }
-            case 9 /* Union */: {
+            case 8 /* Union */: {
                 return (0, types_1.findSubtype)(type, (subtype) => canBeFalsy(subtype, recursionCount)) !== undefined;
             }
-            case 5 /* Function */:
-            case 6 /* OverloadedFunction */:
-            case 8 /* Module */:
-            case 10 /* TypeVar */: {
+            case 4 /* Function */:
+            case 5 /* OverloadedFunction */:
+            case 7 /* Module */:
+            case 9 /* TypeVar */: {
                 return false;
             }
-            case 7 /* Class */: {
+            case 6 /* Class */: {
                 if (types_1.TypeBase.isInstantiable(type)) {
                     return false;
                 }
@@ -1133,7 +1138,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return true;
                 }
-                return false;
+                // If the class is not final, it's possible that it could be overridden
+                // such that it is falsy. To be fully correct, we'd need to do the
+                // following:
+                // return !ClassType.isFinal(type);
+                // However, pragmatically if the class is not an `object`, it's typically
+                // OK to assume that it will not be overridden in this manner.
+                return types_1.ClassType.isBuiltIn(type, 'object');
             }
         }
     }
@@ -1145,25 +1156,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         recursionCount++;
         switch (type.category) {
             case 1 /* Unknown */:
-            case 5 /* Function */:
-            case 6 /* OverloadedFunction */:
-            case 8 /* Module */:
-            case 10 /* TypeVar */:
-            case 4 /* Never */:
+            case 4 /* Function */:
+            case 5 /* OverloadedFunction */:
+            case 7 /* Module */:
+            case 9 /* TypeVar */:
+            case 3 /* Never */:
             case 2 /* Any */: {
                 return true;
             }
-            case 9 /* Union */: {
+            case 8 /* Union */: {
                 return (0, types_1.findSubtype)(type, (subtype) => canBeTruthy(subtype, recursionCount)) !== undefined;
             }
-            case 0 /* Unbound */:
-            case 3 /* None */: {
+            case 0 /* Unbound */: {
                 return false;
             }
-            case 7 /* Class */: {
+            case 6 /* Class */: {
                 if (types_1.TypeBase.isInstantiable(type)) {
                     return true;
                 }
+                if ((0, typeUtils_1.isNoneInstance)(type)) {
+                    return false;
+                }
                 // Check for Tuple[()] (an empty tuple).
                 if ((0, typeUtils_1.isTupleClass)(type)) {
                     if (type.tupleTypeArguments && type.tupleTypeArguments.length === 0) {
@@ -1255,6 +1268,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'bool')) {
                     return types_1.ClassType.cloneWithLiteral(concreteSubtype, /* value */ true);
                 }
+                // If the object is a "None" instance, we can eliminate it.
+                if ((0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
+                    return undefined;
+                }
+                // If this is an instance of a class that cannot be subclassed,
+                // we cannot say definitively that it's not falsy because a subclass
+                // could override `__bool__`. For this reason, the code should not
+                // remove any classes that are not final.
+                // if (!ClassType.isFinal(concreteSubtype)) {
+                //     return subtype;
+                // }
+                // However, we're going to pragmatically assume that any classes
+                // other than `object` will not be overridden in this manner.
+                if (types_1.ClassType.isBuiltIn(concreteSubtype, 'object')) {
+                    return subtype;
+                }
             }
             // If it's possible for the type to be truthy, include it.
             if (canBeTruthy(subtype)) {
@@ -1263,113 +1292,109 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         });
     }
-    // Gets a member type from an object and if it's a function binds
-    // it to the object. If bindToClass is undefined, the binding is done
+    // Gets a member type from an object or class. If it's a function, binds
+    // it to the object or class. If selfType is undefined, the binding is done
     // 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, memberAccessFlags = 0 /* None */, bindToType) {
-        let memberInfo = getTypeOfClassMemberName(errorNode, types_1.ClassType.cloneAsInstantiable(objectType), 
-        /* isAccessedThroughObject */ true, memberName, usage, diag, memberAccessFlags | 16 /* DisallowClassVarWrites */, bindToType);
-        if (!memberInfo) {
-            const metaclass = objectType.details.effectiveMetaclass;
-            if (metaclass &&
-                (0, types_1.isInstantiableClass)(metaclass) &&
-                !types_1.ClassType.isBuiltIn(metaclass, 'type') &&
-                !types_1.ClassType.isSameGenericClass(metaclass, objectType)) {
-                memberInfo = getTypeOfClassMemberName(errorNode, metaclass, 
-                /* isAccessedThroughObject */ false, memberName, usage, 
-                /* diag */ undefined, memberAccessFlags |
-                    2 /* AccessInstanceMembersOnly */ |
-                    128 /* SkipAttributeAccessOverride */, types_1.ClassType.cloneAsInstantiable(objectType));
-            }
-        }
-        if (memberInfo && !memberInfo.isSetTypeError) {
-            return {
-                type: memberInfo.type,
-                classType: memberInfo.classType,
-                isIncomplete: !!memberInfo.isTypeIncomplete,
-                isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
-                memberAccessDeprecationInfo: memberInfo.memberAccessDeprecationInfo,
-            };
-        }
-        return undefined;
-    }
-    // Gets a member type from a class and if it's a function binds
-    // it to the class.
-    function getTypeOfClassMember(errorNode, classType, memberName, usage = { method: 'get' }, diag = undefined, memberAccessFlags = 0 /* None */, bindToType) {
-        let memberInfo;
-        const classDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
-        const metaclassDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
-        let considerMetaclassOnly = (memberAccessFlags & 64 /* ConsiderMetaclassOnly */) !== 0;
-        if (types_1.ClassType.isPartiallyEvaluated(classType)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classDefinitionCycle().format({ name: classType.details.name }), errorNode);
+    function getTypeOfBoundMember(errorNode, objectType, memberName, usage = { method: 'get' }, diag = undefined, flags = 0 /* Default */, selfType, recursionCount = 0) {
+        if (types_1.ClassType.isPartiallyEvaluated(objectType)) {
+            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() };
         }
-        const metaclass = classType.details.effectiveMetaclass;
+        // Determine the class that was used to instantiate the objectType.
+        // If the objectType is a class itself, then the class used to instantiate
+        // it is the metaclass.
+        const objectTypeIsInstantiable = types_1.TypeBase.isInstantiable(objectType);
+        const metaclass = objectType.details.effectiveMetaclass;
+        let memberInfo;
+        // If the object type is an instantiable (i.e. it derives from "type") and
+        // we've been asked not to consider instance members, don't look in the class.
+        // Consider only the metaclass class variables in this case.
+        let skipObjectTypeLookup = objectTypeIsInstantiable && (flags & 16 /* SkipInstanceMembers */) !== 0;
         // Look up the attribute in the metaclass first. If the member is a descriptor
-        // (an object with a __get__ method) and the access is a 'get', the Python runtime
-        // uses this metaclass descriptor to satisfy the lookup. Skip this costly lookup
-        // in the common case where the metaclass is 'type' since we know that `type` doesn't
-        // have any attributes that are descriptors.
+        // (an object with a __get__ and __set__ method) and the access is a 'get',
+        // the Python runtime uses this descriptor to satisfy the lookup. Skip this
+        // costly lookup in the common case where the metaclass is 'type' since we know
+        // that `type` doesn't have any attributes that are descriptors.
         if (usage.method === 'get' &&
+            objectTypeIsInstantiable &&
             metaclass &&
             (0, types_1.isInstantiableClass)(metaclass) &&
             !types_1.ClassType.isBuiltIn(metaclass, 'type') &&
-            !types_1.ClassType.isSameGenericClass(metaclass, classType)) {
-            const metaclassMemberInfo = getTypeOfClassMemberName(errorNode, metaclass, 
-            /* isAccessedThroughObject */ false, memberName, usage, metaclassDiag, memberAccessFlags | 128 /* SkipAttributeAccessOverride */, classType);
-            if (metaclassMemberInfo && (0, typeUtils_1.isDescriptorInstance)(metaclassMemberInfo.type)) {
-                considerMetaclassOnly = true;
+            !types_1.ClassType.isSameGenericClass(metaclass, objectType)) {
+            const descMemberInfo = getTypeOfClassMemberName(errorNode, metaclass, memberName, usage, 
+            /* diag */ undefined, flags | 512 /* SkipAttributeAccessOverride */, objectType);
+            if (descMemberInfo) {
+                const isProperty = (0, types_1.isClassInstance)(descMemberInfo.type) && types_1.ClassType.isPropertyClass(descMemberInfo.type);
+                if ((0, typeUtils_1.isDescriptorInstance)(descMemberInfo.type, /* requireSetter */ true) || isProperty) {
+                    skipObjectTypeLookup = true;
+                }
             }
         }
-        // Look up the attribute in the class object.
-        if (!memberInfo && !considerMetaclassOnly) {
-            memberInfo = getTypeOfClassMemberName(errorNode, classType, 
-            /* isAccessedThroughObject */ false, memberName, usage, classDiag, memberAccessFlags | 1 /* AccessClassMembersOnly */, bindToType);
-        }
-        const isMemberPresentOnClass = (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.classType) !== undefined;
-        // If it wasn't found on the class, see if it's part of the metaclass.
-        if (!memberInfo) {
-            const metaclass = classType.details.effectiveMetaclass;
-            if (metaclass && (0, types_1.isInstantiableClass)(metaclass) && !types_1.ClassType.isSameGenericClass(metaclass, classType)) {
-                memberInfo = getTypeOfClassMemberName(errorNode, metaclass, 
-                /* isAccessedThroughObject */ true, memberName, usage, metaclassDiag, memberAccessFlags, classType);
+        let subDiag;
+        if (!skipObjectTypeLookup) {
+            let effectiveFlags = flags;
+            if (objectTypeIsInstantiable) {
+                effectiveFlags |= 16 /* SkipInstanceMembers */ | 512 /* SkipAttributeAccessOverride */;
+                effectiveFlags &= ~32 /* SkipClassMembers */;
             }
-        }
-        if (memberInfo && !memberInfo.isSetTypeError) {
+            else {
+                effectiveFlags |= 128 /* DisallowClassVarWrites */;
+            }
+            subDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
+            // See if the member is present in the object itself.
+            memberInfo = getTypeOfClassMemberName(errorNode, objectType, memberName, usage, subDiag, effectiveFlags, selfType);
+        }
+        // If it wasn't found on the object, see if it's part of the metaclass.
+        if (!memberInfo && metaclass && (0, types_1.isInstantiableClass)(metaclass)) {
+            let effectiveFlags = flags;
+            // Class members cannot be accessed on a class's metaclass through
+            // an instance of a class. Limit access to metaclass instance members
+            // in this case.
+            if (!objectTypeIsInstantiable) {
+                effectiveFlags |= 32 /* SkipClassMembers */ | 512 /* SkipAttributeAccessOverride */;
+                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), 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) {
+                subDiag = metaclassDiag;
+            }
+        }
+        if (memberInfo && !memberInfo.isDescriptorError) {
             return {
                 type: memberInfo.type,
+                classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
                 memberAccessDeprecationInfo: memberInfo.memberAccessDeprecationInfo,
             };
         }
-        // Determine whether to use the class or metaclass diagnostic addendum.
-        const subDiag = isMemberPresentOnClass ? classDiag : metaclassDiag;
         if (diag && subDiag) {
             diag.addAddendum(subDiag);
         }
         return undefined;
     }
-    function getBoundMethod(classType, memberName, recursionCount = 0, treatConstructorAsClassMember = false) {
-        const memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, 8 /* SkipInstanceVariables */);
-        if (memberInfo) {
-            const unboundMethodType = getTypeOfMember(memberInfo);
-            if ((0, types_1.isFunction)(unboundMethodType) || (0, types_1.isOverloadedFunction)(unboundMethodType)) {
-                const boundMethod = bindFunctionToClassOrObject(types_1.ClassType.cloneAsInstance(classType), unboundMethodType, 
-                /* memberClass */ undefined, treatConstructorAsClassMember, 
-                /* firstParamType */ undefined, 
-                /* diag */ undefined, recursionCount);
-                if (boundMethod) {
-                    return boundMethod;
-                }
-            }
-            else if ((0, types_1.isAnyOrUnknown)(unboundMethodType)) {
-                const unknownFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* SkipArgsKwargsCompatibilityCheck */);
-                types_1.FunctionType.addDefaultParameters(unknownFunction);
-                return unknownFunction;
-            }
+    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;
+        }
+        if ((0, types_1.isFunction)(boundMethodResult.type) || (0, types_1.isOverloadedFunction)(boundMethodResult.type)) {
+            return boundMethodResult.type;
+        }
+        if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
+            const unknownFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* SkipArgsKwargsCompatibilityCheck */);
+            types_1.FunctionType.addDefaultParameters(unknownFunction);
+            return unknownFunction;
         }
         return undefined;
     }
@@ -1379,7 +1404,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getCallSignatureInfo(callNode, activeIndex, activeOrFake) {
         const exprNode = callNode.leftExpression;
         const callType = getType(exprNode);
-        if (callType === undefined) {
+        if (!callType) {
             return undefined;
         }
         const argList = [];
@@ -1424,7 +1449,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* skipUnknownArgCheck */ true);
             });
             signatures.push({
-                type,
+                type: expandTypedKwargs(type),
                 activeParam: callResult === null || callResult === void 0 ? void 0 : callResult.activeParam,
             });
         }
@@ -1440,44 +1465,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         (0, typeUtils_1.doForEachSubtype)(callType, (subtype) => {
             switch (subtype.category) {
-                case 5 /* Function */:
-                case 6 /* OverloadedFunction */: {
+                case 4 /* Function */:
+                case 5 /* OverloadedFunction */: {
                     addFunctionToSignature(subtype);
                     break;
                 }
-                case 7 /* Class */: {
+                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__', 
-                            /* recursionCount */ undefined, 
-                            /* treatConstructorAsClassMember */ true);
-                            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);
                         }
@@ -1494,6 +1521,48 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             signatures,
         };
     }
+    // If the function includes a `**kwargs: Unpack[TypedDict]` parameter, the
+    // parameter is expanded to include individual keyword args.
+    function expandTypedKwargs(functionType) {
+        var _a;
+        const kwargsIndex = functionType.details.parameters.findIndex((param) => param.category === 2 /* KwargsDict */);
+        if (kwargsIndex < 0) {
+            return functionType;
+        }
+        (0, debug_1.assert)(kwargsIndex === functionType.details.parameters.length - 1);
+        const kwargsType = types_1.FunctionType.getEffectiveParameterType(functionType, kwargsIndex);
+        if (!(0, types_1.isClassInstance)(kwargsType) || !types_1.ClassType.isTypedDictClass(kwargsType) || !kwargsType.isUnpacked) {
+            return functionType;
+        }
+        const tdEntries = (_a = kwargsType.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : kwargsType.details.typedDictEntries;
+        if (!tdEntries) {
+            return functionType;
+        }
+        const newFunction = types_1.FunctionType.clone(functionType);
+        newFunction.details.parameters.splice(kwargsIndex);
+        if (newFunction.specializedTypes) {
+            newFunction.specializedTypes.parameterTypes.splice(kwargsIndex);
+        }
+        const kwSeparatorIndex = functionType.details.parameters.findIndex((param) => param.category === 1 /* ArgsList */);
+        // Add a keyword separator if necessary.
+        if (kwSeparatorIndex < 0) {
+            types_1.FunctionType.addParameter(newFunction, {
+                category: 1 /* ArgsList */,
+                type: types_1.AnyType.create(),
+            });
+        }
+        tdEntries.forEach((tdEntry, name) => {
+            types_1.FunctionType.addParameter(newFunction, {
+                category: 0 /* Simple */,
+                name,
+                hasDeclaredType: true,
+                type: tdEntry.valueType,
+                hasDefault: !tdEntry.isRequired,
+                defaultType: tdEntry.valueType,
+            });
+        });
+        return newFunction;
+    }
     // Determines whether the specified expression is an explicit TypeAlias declaration.
     function isDeclaredTypeAlias(expression) {
         if (expression.nodeType === 54 /* TypeAnnotation */) {
@@ -1530,8 +1599,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (enclosingClass && enclosingClass.nodeType === 10 /* Class */) {
                             const classTypeInfo = getTypeOfClass(enclosingClass);
                             if (classTypeInfo) {
-                                const classMemberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, expression.value, 8 /* SkipInstanceVariables */ |
-                                    32 /* DeclaredTypesOnly */);
+                                const classMemberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, expression.value, 16 /* SkipInstanceMembers */ | 64 /* DeclaredTypesOnly */);
                                 if (classMemberInfo) {
                                     symbol = classMemberInfo.symbol;
                                 }
@@ -1548,7 +1616,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 16777218 /* MemberAccessBaseDefaults */).type);
                 let classMemberInfo;
                 if ((0, types_1.isClassInstance)(baseType)) {
-                    classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.memberName.value, 32 /* DeclaredTypesOnly */);
+                    classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.memberName.value, 64 /* DeclaredTypesOnly */);
                     classOrObjectBase = baseType;
                     memberAccessClass = classMemberInfo === null || classMemberInfo === void 0 ? void 0 : classMemberInfo.classType;
                     // If this is an instance member (e.g. a dataclass field), don't
@@ -1559,7 +1627,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     useDescriptorSetterType = true;
                 }
                 else if ((0, types_1.isInstantiableClass)(baseType)) {
-                    classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseType, expression.memberName.value, 8 /* SkipInstanceVariables */ | 32 /* DeclaredTypesOnly */);
+                    classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseType, expression.memberName.value, 16 /* SkipInstanceMembers */ | 64 /* DeclaredTypesOnly */);
                     classOrObjectBase = baseType;
                     memberAccessClass = classMemberInfo === null || classMemberInfo === void 0 ? void 0 : classMemberInfo.classType;
                 }
@@ -1571,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)) {
@@ -1602,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;
                         }
@@ -1621,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);
                         }
                     }
                 }
@@ -1668,17 +1721,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Validates that the type is an iterator and returns the iterated type
     // (i.e. the type returned from the '__next__' or '__anext__' method).
-    function getTypeOfIterator(typeResult, isAsync, errorNode) {
+    function getTypeOfIterator(typeResult, isAsync, errorNode, emitNotIterableError = true) {
         const iterMethodName = isAsync ? '__aiter__' : '__iter__';
         const nextMethodName = isAsync ? '__anext__' : '__next__';
         let isValidIterator = true;
         let type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(typeResult.type);
         type = makeTopLevelTypeVarsConcrete(type);
         if ((0, typeUtils_1.isOptionalType)(type)) {
-            if (errorNode && !typeResult.isIncomplete) {
+            if (!typeResult.isIncomplete && emitNotIterableError) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalIterable, diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.Localizer.Diagnostic.noneNotIterable(), errorNode);
             }
-            type = (0, types_1.removeNoneFromUnion)(type);
+            type = (0, typeUtils_1.removeNoneFromUnion)(type);
         }
         const iterableType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             subtype = makeTopLevelTypeVarsConcrete(subtype);
@@ -1687,33 +1740,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             const diag = new diagnostic_1.DiagnosticAddendum();
             if ((0, types_1.isClass)(subtype)) {
-                let iterReturnType;
-                if (types_1.TypeBase.isInstance(subtype)) {
-                    // Handle an empty tuple specially.
-                    if ((0, typeUtils_1.isTupleClass)(subtype) &&
-                        subtype.tupleTypeArguments &&
-                        subtype.tupleTypeArguments.length === 0) {
-                        return types_1.NeverType.createNever();
-                    }
-                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, [], errorNode);
-                }
-                else if (types_1.TypeBase.isInstantiable(subtype) &&
-                    subtype.details.effectiveMetaclass &&
-                    (0, types_1.isInstantiableClass)(subtype.details.effectiveMetaclass)) {
-                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, [], errorNode, subtype);
-                }
+                // Handle an empty tuple specially.
+                if (types_1.TypeBase.isInstance(subtype) &&
+                    (0, typeUtils_1.isTupleClass)(subtype) &&
+                    subtype.tupleTypeArguments &&
+                    subtype.tupleTypeArguments.length === 0) {
+                    return types_1.NeverType.createNever();
+                }
+                const iterReturnType = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode);
                 if (!iterReturnType) {
                     // There was no __iter__. See if we can fall back to
                     // the __getitem__ method instead.
                     if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
-                        const getItemReturnType = getSpecializedReturnType(subtype, '__getitem__', [
+                        const getItemReturnType = getTypeOfMagicMethodCall(subtype, '__getitem__', [
                             {
-                                argumentCategory: 0 /* Simple */,
-                                typeResult: {
-                                    type: intClassType && (0, types_1.isInstantiableClass)(intClassType)
-                                        ? types_1.ClassType.cloneAsInstance(intClassType)
-                                        : types_1.UnknownType.create(),
-                                },
+                                type: intClassType && (0, types_1.isInstantiableClass)(intClassType)
+                                    ? types_1.ClassType.cloneAsInstance(intClassType)
+                                    : types_1.UnknownType.create(),
                             },
                         ], errorNode);
                         if (getItemReturnType) {
@@ -1730,7 +1773,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return subtype;
                         }
                         if ((0, types_1.isClassInstance)(subtype)) {
-                            let nextReturnType = getSpecializedReturnType(subtype, nextMethodName, [], errorNode);
+                            let nextReturnType = getTypeOfMagicMethodCall(subtype, nextMethodName, [], errorNode);
                             if (!nextReturnType) {
                                 iterReturnTypeDiag.addMessage(localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
                                     name: nextMethodName,
@@ -1765,7 +1808,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     diag.addAddendum(iterReturnTypeDiag);
                 }
             }
-            if (errorNode && !typeResult.isIncomplete) {
+            if (!typeResult.isIncomplete && emitNotIterableError) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIterable().format({ type: printType(subtype) }) + diag.getString(), errorNode);
             }
             isValidIterator = false;
@@ -1774,35 +1817,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return isValidIterator ? { type: iterableType, isIncomplete: typeResult.isIncomplete } : undefined;
     }
     // Validates that the type is an iterable and returns the iterable type argument.
-    function getTypeOfIterable(typeResult, isAsync, errorNode) {
+    function getTypeOfIterable(typeResult, isAsync, errorNode, emitNotIterableError = true) {
         const iterMethodName = isAsync ? '__aiter__' : '__iter__';
         let isValidIterable = true;
         let type = makeTopLevelTypeVarsConcrete(typeResult.type);
         if ((0, typeUtils_1.isOptionalType)(type)) {
-            if (errorNode && !typeResult.isIncomplete) {
+            if (!typeResult.isIncomplete && emitNotIterableError) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalIterable, diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.Localizer.Diagnostic.noneNotIterable(), errorNode);
             }
-            type = (0, types_1.removeNoneFromUnion)(type);
+            type = (0, typeUtils_1.removeNoneFromUnion)(type);
         }
         const iterableType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
             }
             if ((0, types_1.isClass)(subtype)) {
-                let iterReturnType;
-                if (types_1.TypeBase.isInstance(subtype)) {
-                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, [], errorNode);
-                }
-                else if (types_1.TypeBase.isInstantiable(subtype) &&
-                    subtype.details.effectiveMetaclass &&
-                    (0, types_1.isInstantiableClass)(subtype.details.effectiveMetaclass)) {
-                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, [], errorNode, subtype);
-                }
+                const iterReturnType = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode);
                 if (iterReturnType) {
                     return makeTopLevelTypeVarsConcrete(iterReturnType);
                 }
             }
-            if (errorNode) {
+            if (emitNotIterableError) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIterable().format({ type: printType(subtype) }), errorNode);
             }
             isValidIterable = false;
@@ -1828,7 +1863,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // Handle the case where the type is synthesized (used for
                         // dataclasses).
                         if (synthesizedType) {
-                            isObjectHashable = !(0, types_1.isNoneInstance)(synthesizedType);
+                            isObjectHashable = !(0, typeUtils_1.isNoneInstance)(synthesizedType);
                         }
                         else {
                             // Assume that if '__hash__' is declared as a variable, it is
@@ -1851,13 +1886,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return isTypeHashable;
     }
     function getTypedDictClassType() {
-        return typedDictPrivateClassType;
+        return typedDictPrivateClassType && (0, types_1.isInstantiableClass)(typedDictPrivateClassType)
+            ? typedDictPrivateClassType
+            : undefined;
     }
     function getTupleClassType() {
-        return tupleClassType;
+        return tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType) ? tupleClassType : undefined;
     }
     function getObjectType() {
-        return objectType;
+        return objectType !== null && objectType !== void 0 ? objectType : types_1.UnknownType.create();
+    }
+    function getNoneType() {
+        return noneType !== null && noneType !== void 0 ? noneType : types_1.UnknownType.create();
     }
     function getTypingType(node, symbolName) {
         var _a;
@@ -2192,7 +2232,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const classTypeInfo = getTypeOfClass(classDef);
         if (classTypeInfo && (0, types_1.isInstantiableClass)(classTypeInfo.classType)) {
-            let memberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, memberName, isInstanceMember ? 0 /* Default */ : 8 /* SkipInstanceVariables */);
+            let memberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, memberName, isInstanceMember ? 0 /* Default */ : 16 /* SkipInstanceMembers */);
             const memberFields = classTypeInfo.classType.details.fields;
             if (memberInfo) {
                 // Are we accessing an existing member on this class, or is
@@ -2210,7 +2250,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // Determine whether the assignment corresponds to a descriptor
                             // that was assigned as a class variable. If so, then slots will not
                             // apply in this case.
-                            const classMemberDetails = (0, typeUtils_1.lookUpClassMember)(memberClass, memberName, 8 /* SkipInstanceVariables */);
+                            const classMemberDetails = (0, typeUtils_1.lookUpClassMember)(memberClass, memberName, 16 /* SkipInstanceMembers */);
                             let isPotentiallyDescriptor = false;
                             if (classMemberDetails) {
                                 const classMemberSymbolType = getEffectiveTypeOfSymbol(classMemberDetails.symbol);
@@ -2257,7 +2297,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             // Look up the member info again, now that we've potentially updated it.
-            memberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, memberName, 32 /* DeclaredTypesOnly */);
+            memberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, memberName, 64 /* DeclaredTypesOnly */);
             if (!memberInfo && srcExprNode && !isTypeIncomplete) {
                 reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownMemberType, diagnosticRules_1.DiagnosticRule.reportUnknownMemberType, node.memberName, srcType, node, 
                 /* ignoreEmptyContainers */ true);
@@ -2388,6 +2428,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // TypeVar, only the conditions that match the filter will be included.
     function makeTopLevelTypeVarsConcrete(type, makeParamSpecsConcrete = false, conditionFilter) {
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            var _a, _b;
             if ((0, types_1.isParamSpec)(subtype)) {
                 if (subtype.paramSpecAccess === 'args') {
                     if (tupleClassType &&
@@ -2443,22 +2484,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if ((0, types_1.isTypeVar)(subtype) && !subtype.details.recursiveTypeAliasName) {
-                if (subtype.details.boundType) {
-                    const boundType = types_1.TypeBase.isInstantiable(subtype)
-                        ? (0, typeUtils_1.convertToInstantiable)(subtype.details.boundType)
-                        : subtype.details.boundType;
-                    // Handle Self and type[Self] specially.
-                    if (subtype.details.isSynthesizedSelf && (0, types_1.isClass)(boundType)) {
-                        return types_1.ClassType.cloneIncludeSubclasses(boundType);
-                    }
-                    return (0, typeUtils_1.addConditionToType)(boundType, [
-                        {
-                            typeVarName: types_1.TypeVarType.getNameWithScope(subtype),
-                            constraintIndex: 0,
-                            isConstrainedTypeVar: false,
-                        },
-                    ]);
-                }
                 // If this is a recursive type alias placeholder
                 // that hasn't yet been resolved, return it as is.
                 if (subtype.details.recursiveTypeAliasName) {
@@ -2494,32 +2519,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (subtype.details.isExemptFromBoundCheck) {
                     return types_1.AnyType.create();
                 }
-                // Convert to an "object" or "type" instance depending on whether
-                // it's instantiable.
-                if (types_1.TypeBase.isInstantiable(subtype)) {
-                    if (typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
-                        return subtype.details.isSynthesized
-                            ? typeClassType
-                            : (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(typeClassType), [
-                                {
-                                    typeVarName: types_1.TypeVarType.getNameWithScope(subtype),
-                                    constraintIndex: 0,
-                                    isConstrainedTypeVar: false,
-                                },
-                            ]);
-                    }
-                }
-                else if (objectType) {
-                    return subtype.details.isSynthesized
-                        ? objectType
-                        : (0, typeUtils_1.addConditionToType)(objectType, [
-                            {
-                                typeVarName: types_1.TypeVarType.getNameWithScope(subtype),
-                                constraintIndex: 0,
-                                isConstrainedTypeVar: false,
-                            },
-                        ]);
+                // Fall back to a bound of "object" if no bound is provided.
+                let boundType = (_b = (_a = subtype.details.boundType) !== null && _a !== void 0 ? _a : objectType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
+                // Handle Self and type[Self] specially.
+                if (subtype.details.isSynthesizedSelf && (0, types_1.isClass)(boundType)) {
+                    return types_1.ClassType.cloneIncludeSubclasses(boundType);
                 }
+                return (0, typeUtils_1.addConditionToType)(boundType, [
+                    {
+                        typeVarName: types_1.TypeVarType.getNameWithScope(subtype),
+                        constraintIndex: 0,
+                        isConstrainedTypeVar: false,
+                    },
+                ]);
                 return types_1.AnyType.create();
             }
             return subtype;
@@ -2531,7 +2544,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // its bound type and a constrained TypeVar is expanded to its individual
     // constrained types). If conditionFilter is specified, conditions that
     // do not match will be ignored.
-    function mapSubtypesExpandTypeVars(type, conditionFilter, callback, recursionCount = 0) {
+    function mapSubtypesExpandTypeVars(type, conditionFilter, callback, sortSubtypes = false, recursionCount = 0) {
         const newSubtypes = [];
         let typeChanged = false;
         function expandSubtype(unexpandedType, isLastSubtype) {
@@ -2559,10 +2572,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     newSubtypes.push(transformedType);
                 }
                 return undefined;
-            });
+            }, sortSubtypes);
         }
         if ((0, types_1.isUnion)(type)) {
-            type.subtypes.forEach((subtype, index) => {
+            const subtypes = sortSubtypes ? (0, typeUtils_1.sortTypes)(type.subtypes) : type.subtypes;
+            subtypes.forEach((subtype, index) => {
                 expandSubtype(subtype, index === type.subtypes.length - 1);
             });
         }
@@ -2574,7 +2588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const newType = (0, types_1.combineTypes)(newSubtypes);
         // Do our best to retain type aliases.
-        if (newType.category === 9 /* Union */) {
+        if (newType.category === 8 /* Union */) {
             types_1.UnionType.addTypeAliasSource(newType, type);
         }
         return newType;
@@ -2604,7 +2618,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 const filteredTypeArg = mapSubtypesExpandTypeVars(typeArg, conditionFilter, (expandedSubtype) => {
                     return expandedSubtype;
-                }, recursionCount);
+                }, 
+                /* sortSubtypes */ undefined, recursionCount);
                 if (filteredTypeArg !== typeArg) {
                     typeWasTransformed = true;
                 }
@@ -2835,39 +2850,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             fileInfo.accessedSymbolSet.add(symbol.id);
         }
     }
-    function getSpecializedReturnType(objType, memberName, argList, errorNode, bindToClass) {
-        const classMember = (0, typeUtils_1.lookUpObjectMember)(objType, memberName, 8 /* SkipInstanceVariables */);
-        if (!classMember) {
-            return undefined;
-        }
-        const memberTypeResult = getTypeOfMemberInternal(classMember, objType);
-        if (!memberTypeResult) {
-            return undefined;
-        }
-        const memberType = memberTypeResult.type;
-        if ((0, types_1.isAnyOrUnknown)(memberType)) {
-            return memberType;
-        }
-        if ((0, types_1.isFunction)(memberType) || (0, types_1.isOverloadedFunction)(memberType)) {
-            const methodType = bindFunctionToClassOrObjectWithErrors(bindToClass || objType, memberType, classMember && (0, types_1.isInstantiableClass)(classMember.classType) ? classMember.classType : undefined, errorNode, 
-            /* treatConstructorAsClassMember */ false, 
-            /* firstParamType */ bindToClass);
-            if (methodType) {
-                if ((0, types_1.isOverloadedFunction)(methodType)) {
-                    if (errorNode) {
-                        const bestOverload = getBestOverloadForArguments(errorNode, { type: methodType, isIncomplete: memberTypeResult.isIncomplete }, argList);
-                        if (bestOverload) {
-                            return getFunctionEffectiveReturnType(bestOverload);
-                        }
-                    }
-                }
-                else {
-                    return getFunctionEffectiveReturnType(methodType);
-                }
-            }
-        }
-        return undefined;
-    }
     function getTypeOfName(node, flags) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
@@ -3330,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 {
@@ -3393,6 +3375,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, isRescoped: false, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
+        var _a;
         // Compute flags specifically for evaluating the left expression.
         let leftExprFlags = 16777218 /* MemberAccessBaseDefaults */;
         leftExprFlags |=
@@ -3458,12 +3441,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (baseTypeResult.isIncomplete) {
             typeResult.isIncomplete = true;
         }
+        // See if we need to log an "unknown member access" diagnostic.
+        let skipPartialUnknownCheck = typeResult.isIncomplete;
+        // Don't report an error if the type is a partially-specialized
+        // class being passed as an argument. This comes up frequently in
+        // cases where a type is passed as an argument (e.g. "defaultdict(list)").
+        // It can also come up in cases like "isinstance(x, (list, dict))".
+        if ((0, types_1.isInstantiableClass)(typeResult.type)) {
+            const argNode = ParseTreeUtils.getParentNodeOfType(node, 1 /* Argument */);
+            if (argNode && ((_a = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
+                skipPartialUnknownCheck = true;
+            }
+        }
+        if (!skipPartialUnknownCheck) {
+            reportPossibleUnknownAssignment(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportUnknownMemberType, diagnosticRules_1.DiagnosticRule.reportUnknownMemberType, node.memberName, typeResult.type, node, 
+            /* ignoreEmptyContainers */ false);
+        }
         // Cache the type information in the member name node.
         writeTypeCache(node.memberName, typeResult, flags);
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
-        var _a, _b, _c;
+        var _a, _b;
         let baseType = baseTypeResult.type;
         const memberName = node.memberName.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
@@ -3486,113 +3485,90 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 baseType = objectType;
             }
         }
-        function getTypeOfNoneBase(subtype) {
-            if (noneType && (0, types_1.isInstantiableClass)(noneType)) {
-                if (types_1.TypeBase.isInstance(subtype)) {
-                    return getTypeOfObjectMember(node.memberName, types_1.ClassType.cloneAsInstance(noneType), memberName, usage, diag);
-                }
-                else {
-                    return getTypeOfClassMember(node.memberName, noneType, memberName, usage, diag);
-                }
-            }
-            return undefined;
-        }
         if ((0, types_1.isParamSpec)(baseType) && baseType.paramSpecAccess) {
             baseType = makeTopLevelTypeVarsConcrete(baseType);
         }
         switch (baseType.category) {
             case 2 /* Any */:
             case 1 /* Unknown */:
-            case 4 /* Never */: {
+            case 3 /* Never */: {
                 type = baseType;
                 break;
             }
-            case 10 /* TypeVar */: {
+            case 0 /* Unbound */: {
+                break;
+            }
+            case 9 /* TypeVar */: {
                 if (baseType.details.isParamSpec) {
-                    if (memberName === 'args') {
-                        const paramNode = ParseTreeUtils.getEnclosingParameter(node);
-                        if (!paramNode || paramNode.category !== 1 /* ArgsList */) {
-                            addError(localize_1.Localizer.Diagnostic.paramSpecArgsUsage(), node);
-                            return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
-                        }
-                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'args'), isIncomplete };
-                    }
-                    if (memberName === 'kwargs') {
+                    // Handle special cases for "P.args" and "P.kwargs".
+                    if (memberName === 'args' || memberName === 'kwargs') {
+                        const isArgs = memberName === 'args';
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
-                        if (!paramNode || paramNode.category !== 2 /* KwargsDict */) {
-                            addError(localize_1.Localizer.Diagnostic.paramSpecKwargsUsage(), node);
-                            return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
+                        const expectedCategory = isArgs ? 1 /* ArgsList */ : 2 /* KwargsDict */;
+                        if (!paramNode || paramNode.category !== expectedCategory) {
+                            const errorMessage = isArgs
+                                ? localize_1.Localizer.Diagnostic.paramSpecArgsUsage()
+                                : localize_1.Localizer.Diagnostic.paramSpecKwargsUsage();
+                            addError(errorMessage, node);
+                            type = types_1.UnknownType.create(isIncomplete);
+                            break;
                         }
-                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'kwargs'), isIncomplete };
+                        type = types_1.TypeVarType.cloneForParamSpecAccess(baseType, memberName);
+                        break;
                     }
                     if (!isIncomplete) {
                         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecUnknownMember().format({ name: memberName }), node);
                     }
-                    return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
+                    type = types_1.UnknownType.create(isIncomplete);
+                    break;
                 }
+                // It's illegal to reference a member from a type variable.
                 if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0) {
                     if (!isIncomplete) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNoMember().format({
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNoMember().format({
                             type: printType(baseType),
                             name: memberName,
                         }), node.leftExpression);
                     }
-                    return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
+                    type = types_1.UnknownType.create(isIncomplete);
+                    break;
                 }
                 if (baseType.details.recursiveTypeAliasName) {
-                    return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
+                    type = types_1.UnknownType.create(/* isIncomplete */ true);
+                    isIncomplete = true;
+                    break;
                 }
-                if (!baseType.details.isVariadic) {
-                    return getTypeOfMemberAccessWithBaseType(node, {
-                        type: makeTopLevelTypeVarsConcrete(baseType),
-                        bindToType: baseType,
-                        isIncomplete,
-                    }, usage, 0 /* None */);
+                if (baseType.details.isVariadic) {
+                    break;
                 }
-                break;
+                return getTypeOfMemberAccessWithBaseType(node, {
+                    type: makeTopLevelTypeVarsConcrete(baseType),
+                    bindToSelfType: types_1.TypeBase.isInstantiable(baseType) ? (0, typeUtils_1.convertToInstance)(baseType) : baseType,
+                    isIncomplete,
+                }, usage, 0 /* None */);
             }
-            case 7 /* Class */: {
-                if (types_1.TypeBase.isInstantiable(baseType)) {
-                    const typeResult = getTypeOfClassMember(node.memberName, baseType, memberName, usage, diag, 0 /* None */, baseTypeResult.bindToType);
-                    type = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type;
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
-                        isIncomplete = true;
-                    }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
-                        isAsymmetricAccessor = true;
-                    }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
-                        memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
-                    }
+            case 6 /* Class */: {
+                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));
                 }
-                else {
-                    // Handle the special case of 'name' and 'value' members within an enum.
-                    const enumMemberResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
-                    if (enumMemberResult) {
-                        return enumMemberResult;
-                    }
-                    const typeResult = getTypeOfObjectMember(node.memberName, baseType, memberName, usage, diag, 
-                    /* memberAccessFlags */ undefined, baseTypeResult.bindToType);
-                    if (typeResult) {
-                        type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
-                    }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
-                        isIncomplete = true;
-                    }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
-                        isAsymmetricAccessor = true;
-                    }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
-                        memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
-                    }
+                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
+                    isIncomplete = true;
+                }
+                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
+                    isAsymmetricAccessor = true;
+                }
+                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
+                    memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
                 }
                 break;
             }
-            case 8 /* Module */: {
+            case 7 /* Module */: {
                 const symbol = types_1.ModuleType.getField(baseType, memberName);
                 if (symbol && !symbol.isExternallyHidden()) {
                     if (usage.method === 'get') {
-                        setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(node), symbol, node.memberName);
+                        setSymbolAccessed(fileInfo, symbol, node.memberName);
                     }
                     type = getEffectiveTypeOfSymbolForUsage(symbol, 
                     /* usageNode */ undefined, 
@@ -3608,12 +3584,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         type = types_1.UnknownType.create(/* isIncomplete */ true);
                     }
                     if (symbol.isPrivateMember()) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportPrivateUsage, diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.Localizer.Diagnostic.privateUsedOutsideOfModule().format({
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportPrivateUsage, diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.Localizer.Diagnostic.privateUsedOutsideOfModule().format({
                             name: memberName,
                         }), node.memberName);
                     }
                     if (symbol.isPrivatePyTypedImport()) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportPrivateImportUsage, diagnosticRules_1.DiagnosticRule.reportPrivateImportUsage, localize_1.Localizer.Diagnostic.privateImportFromPyTypedModule().format({
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportPrivateImportUsage, diagnosticRules_1.DiagnosticRule.reportPrivateImportUsage, localize_1.Localizer.Diagnostic.privateImportFromPyTypedModule().format({
                             name: memberName,
                             module: baseType.moduleName,
                         }), node.memberName);
@@ -3656,10 +3632,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 break;
             }
-            case 9 /* Union */: {
+            case 8 /* Union */: {
                 type = (0, typeUtils_1.mapSubtypes)(baseType, (subtype) => {
-                    if ((0, types_1.isNoneInstance)(subtype)) {
-                        const typeResult = getTypeOfNoneBase(subtype);
+                    if ((0, types_1.isUnbound)(subtype)) {
+                        // Don't do anything if it's unbound. The error will already
+                        // be reported elsewhere.
+                        return undefined;
+                    }
+                    if ((0, typeUtils_1.isNoneInstance)(subtype) && noneType && (0, types_1.isClassInstance)(noneType)) {
+                        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) {
@@ -3667,42 +3648,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                             return type;
                         }
-                        else {
-                            if (!isIncomplete) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalMemberAccess, diagnosticRules_1.DiagnosticRule.reportOptionalMemberAccess, localize_1.Localizer.Diagnostic.noneUnknownMember().format({ name: memberName }), node.memberName);
-                            }
-                            return undefined;
+                        if (!isIncomplete) {
+                            addDiagnostic(fileInfo.diagnosticRuleSet.reportOptionalMemberAccess, diagnosticRules_1.DiagnosticRule.reportOptionalMemberAccess, localize_1.Localizer.Diagnostic.noneUnknownMember().format({ name: memberName }), node.memberName);
                         }
-                    }
-                    else if ((0, types_1.isUnbound)(subtype)) {
-                        // Don't do anything if it's unbound. The error will already
-                        // be reported elsewhere.
                         return undefined;
                     }
-                    else {
-                        const typeResult = getTypeOfMemberAccessWithBaseType(node, {
-                            type: subtype,
-                            isIncomplete: baseTypeResult.isIncomplete,
-                        }, usage, 0 /* None */);
-                        if (typeResult.isIncomplete) {
-                            isIncomplete = true;
-                        }
-                        if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
-                            memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
-                        }
-                        return typeResult.type;
+                    const typeResult = getTypeOfMemberAccessWithBaseType(node, {
+                        type: subtype,
+                        isIncomplete: baseTypeResult.isIncomplete,
+                    }, usage, 0 /* None */);
+                    if (typeResult.isIncomplete) {
+                        isIncomplete = true;
                     }
+                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
+                        memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
+                    }
+                    return typeResult.type;
                 });
                 break;
             }
-            case 5 /* Function */:
-            case 6 /* OverloadedFunction */: {
-                if (memberName === '__defaults__') {
-                    // The "__defaults__" member is not currently defined in the "function"
-                    // class, so we'll special-case it here.
-                    type = types_1.AnyType.create();
-                }
-                else if (memberName === '__self__') {
+            case 4 /* Function */:
+            case 5 /* OverloadedFunction */: {
+                if (memberName === '__self__') {
                     // The "__self__" member is not currently defined in the "function"
                     // class, so we'll special-case it here.
                     const functionType = (0, types_1.isFunction)(baseType) ? baseType : baseType.overloads[0];
@@ -3712,29 +3679,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    if (!functionObj) {
-                        type = types_1.AnyType.create();
-                    }
-                    else {
-                        type = getTypeOfMemberAccessWithBaseType(node, { type: functionObj }, usage, flags).type;
-                    }
-                }
-                break;
-            }
-            case 3 /* None */: {
-                const typeResult = getTypeOfNoneBase(baseType);
-                if (typeResult) {
-                    type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
-                    if (typeResult.isIncomplete) {
-                        isIncomplete = true;
-                    }
+                    type = getTypeOfMemberAccessWithBaseType(node, { type: functionObj !== null && functionObj !== void 0 ? functionObj : types_1.AnyType.create() }, usage, flags).type;
                 }
                 break;
             }
             default:
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeUnsupported().format({ type: printType(baseType) }));
-                break;
+                (0, debug_1.assertNever)(baseType);
         }
+        // If type is undefined, emit a general error message indicating that the
+        // member could not be accessed.
         if (!type) {
             const isFunctionRule = (0, types_1.isFunction)(baseType) ||
                 (0, types_1.isOverloadedFunction)(baseType) ||
@@ -3756,7 +3709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const [ruleSet, rule] = isFunctionRule
                     ? [fileInfo.diagnosticRuleSet.reportFunctionMemberAccess, diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess]
                     : [fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues];
-                addDiagnostic(ruleSet, rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : node.memberName);
+                addDiagnostic(ruleSet, rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node.memberName);
             }
             // If this is member access on a function, use "Any" so if the
             // reportFunctionMemberAccess rule is disabled, we don't trigger
@@ -3766,540 +3719,423 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 256 /* ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node.memberName);
         }
-        // Should we specialize the class?
-        if ((flags & 2 /* DoNotSpecialize */) === 0) {
-            if ((0, types_1.isInstantiableClass)(type) && !type.typeArguments) {
-                type = (_b = createSpecializedClassType(type, /* typeArgs */ undefined, flags, node)) === null || _b === void 0 ? void 0 : _b.type;
-            }
-        }
-        if (usage.method === 'get') {
-            let skipPartialUnknownCheck = isIncomplete;
-            // Don't report an error if the type is a partially-specialized
-            // class being passed as an argument. This comes up frequently in
-            // cases where a type is passed as an argument (e.g. "defaultdict(list)").
-            // It can also come up in cases like "isinstance(x, (list, dict))".
-            if ((0, types_1.isInstantiableClass)(type)) {
-                const argNode = ParseTreeUtils.getParentNodeOfType(node, 1 /* Argument */);
-                if (argNode && ((_c = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 9 /* Call */) {
-                    skipPartialUnknownCheck = true;
-                }
-            }
-            if (!skipPartialUnknownCheck) {
-                reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownMemberType, diagnosticRules_1.DiagnosticRule.reportUnknownMemberType, node.memberName, type, node, 
-                /* ignoreEmptyContainers */ false);
-            }
-        }
         return { type, isIncomplete, isAsymmetricAccessor, isRequired, isNotRequired, memberAccessDeprecationInfo };
     }
-    function getTypeOfClassMemberName(errorNode, classType, isAccessedThroughObject, memberName, usage, diag, flags, bindToType) {
-        var _a, _b;
-        let classLookupFlags = 0 /* Default */;
-        if (flags & 1 /* AccessClassMembersOnly */) {
-            classLookupFlags |= 8 /* SkipInstanceVariables */;
-        }
-        if (flags & 2 /* AccessInstanceMembersOnly */) {
-            classLookupFlags |= 16 /* SkipClassVariables */;
-        }
-        if (flags & 4 /* SkipBaseClasses */) {
-            classLookupFlags |= 2 /* SkipBaseClasses */;
-        }
-        if (flags & 8 /* SkipObjectBaseClass */) {
-            classLookupFlags |= 4 /* SkipObjectBaseClass */;
-        }
-        if (flags & 512 /* SkipTypeBaseClass */) {
-            classLookupFlags |= 64 /* SkipTypeBaseClass */;
-        }
-        if (flags & 256 /* SkipOriginalClass */) {
-            classLookupFlags |= 1 /* SkipOriginalClass */;
-        }
+    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, classLookupFlags | 32 /* DeclaredTypesOnly */);
+        let memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags | 64 /* DeclaredTypesOnly */);
         // If we couldn't find a symbol with a declared type, use
         // a symbol with an inferred type.
         if (!memberInfo) {
-            memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, classLookupFlags);
+            memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags);
         }
-        if (memberInfo) {
-            let type;
-            let isTypeIncomplete = false;
-            if (memberInfo.symbol.isInitVar()) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsInitVar().format({ name: memberName }));
-                return undefined;
-            }
-            if (usage.method !== 'get') {
-                // 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.
-                const containingClass = ParseTreeUtils.getEnclosingClass(errorNode);
-                if (containingClass) {
-                    const containingClassType = (_a = getTypeOfClass(containingClass)) === null || _a === void 0 ? void 0 : _a.classType;
-                    if (containingClassType &&
-                        (0, types_1.isInstantiableClass)(containingClassType) &&
-                        types_1.ClassType.isSameGenericClass(containingClassType, classType)) {
-                        type = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _b === void 0 ? void 0 : _b.type;
-                        if (type && (0, types_1.isInstantiableClass)(memberInfo.classType)) {
-                            type = (0, typeUtils_1.partiallySpecializeType)(type, memberInfo.classType);
-                        }
-                        // If we're setting a class variable via a write through an object,
-                        // this is normally considered a type violation. But it is allowed
-                        // if the class variable is a descriptor object. In this case, we will
-                        // clear the flag that causes an error to be generated.
-                        if (usage.method === 'set' && memberInfo.symbol.isClassVar() && isAccessedThroughObject) {
-                            const selfClass = bindToType || memberName === '__new__' ? undefined : classType;
-                            const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
-                            if (typeResult) {
-                                if ((0, typeUtils_1.isDescriptorInstance)(typeResult.type, /* requireSetter */ true)) {
-                                    type = typeResult.type;
-                                    flags &= 16 /* DisallowClassVarWrites */;
-                                }
-                            }
-                        }
-                        if (!type) {
-                            type = types_1.UnknownType.create();
-                        }
-                    }
-                }
-            }
-            if (!type) {
-                let selfClass = classType;
-                // Determine whether to replace Self variables with a specific
-                // class. Avoid doing this if there's a "bindToType" 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.
-                if (bindToType) {
-                    if ((0, types_1.isTypeVar)(bindToType) && bindToType.details.isSynthesizedSelf) {
-                        selfClass = bindToType;
-                    }
-                    else {
-                        selfClass = undefined;
-                    }
-                }
-                else if (memberName === '__new__') {
-                    selfClass = undefined;
-                }
-                const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
-                if (typeResult) {
-                    type = typeResult.type;
-                    if (typeResult.isIncomplete) {
-                        isTypeIncomplete = true;
-                    }
-                }
-                else {
-                    type = types_1.UnknownType.create();
-                }
-            }
-            // Don't include variables within typed dict classes.
-            if ((0, types_1.isClass)(memberInfo.classType) && types_1.ClassType.isTypedDictClass(memberInfo.classType)) {
-                const typedDecls = memberInfo.symbol.getTypedDeclarations();
-                if (typedDecls.length > 0 && typedDecls[0].type === 1 /* Variable */) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
-                    return undefined;
-                }
-            }
-            if (usage.method === 'get') {
-                // Mark the member accessed if it's not coming from a parent class.
-                if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
-                    types_1.ClassType.isSameGenericClass(memberInfo.classType, classType)) {
-                    setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(errorNode), memberInfo.symbol, errorNode);
-                }
-                // Special-case `__init_subclass` and `__class_getitem__` because
-                // these are always treated as class methods even if they're not
-                // decorated as such.
-                if (memberName === '__init_subclass__' || memberName === '__class_getitem__') {
-                    if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isClassMethod(type)) {
-                        type = types_1.FunctionType.cloneWithNewFlags(type, type.details.flags | 2 /* ClassMethod */);
-                    }
-                }
-            }
-            const descriptorResult = applyDescriptorAccessMethod(type, memberInfo, classType, bindToType, isAccessedThroughObject, flags, errorNode, memberName, usage, diag);
-            if (!descriptorResult) {
-                return undefined;
-            }
-            type = descriptorResult.type;
-            let isSetTypeError = false;
-            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),
-                        }));
-                    }
-                    isSetTypeError = 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)),
-                    }));
-                    isSetTypeError = true;
+        if (!memberInfo) {
+            // 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 && errorNode) {
+                const generalAttrType = applyAttributeAccessOverride(errorNode, classType, usage, memberName, selfType);
+                if (generalAttrType) {
+                    return {
+                        symbol: undefined,
+                        type: generalAttrType.type,
+                        isTypeIncomplete: false,
+                        isDescriptorError: false,
+                        isClassMember: false,
+                        isClassVar: false,
+                        isAsymmetricAccessor: !!generalAttrType.isAsymmetricAccessor,
+                    };
                 }
             }
-            return {
-                symbol: memberInfo.symbol,
-                type,
-                isTypeIncomplete,
-                isSetTypeError,
-                isClassMember: !memberInfo.isInstanceMember,
-                isClassVar: memberInfo.isClassVar,
-                classType: memberInfo.classType,
-                isAsymmetricAccessor: descriptorResult.isAsymmetricAccessor,
-                memberAccessDeprecationInfo: descriptorResult === null || descriptorResult === void 0 ? void 0 : descriptorResult.memberAccessDeprecationInfo,
-            };
+            // Report that the member could not be accessed.
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
+            return undefined;
         }
-        // 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 & (1 /* AccessClassMembersOnly */ | 128 /* SkipAttributeAccessOverride */)) ===
-            0) {
-            const generalAttrType = applyAttributeAccessOverride(classType, errorNode, usage, memberName);
-            if (generalAttrType) {
-                return {
-                    symbol: undefined,
-                    type: generalAttrType.type,
-                    isTypeIncomplete: false,
-                    isSetTypeError: false,
-                    isClassMember: false,
-                    isClassVar: false,
-                    isAsymmetricAccessor: generalAttrType.isAsymmetricAccessor,
-                };
-            }
+        let type;
+        let isTypeIncomplete = false;
+        if (memberInfo.symbol.isInitVar()) {
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsInitVar().format({ name: memberName }));
+            return undefined;
         }
-        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
-        return undefined;
-    }
-    // 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, baseTypeClass, bindToType, isAccessedThroughObject, flags, errorNode, memberName, usage, diag) {
-        const treatConstructorAsClassMember = (flags & 32 /* TreatConstructorAsClassMethod */) !== 0;
-        let isTypeValid = true;
-        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, 8 /* SkipInstanceVariables */);
-                    // 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 (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.
+            const containingClass = ParseTreeUtils.getEnclosingClass(errorNode);
+            if (containingClass) {
+                const containingClassType = (_a = getTypeOfClass(containingClass)) === null || _a === void 0 ? void 0 : _a.classType;
+                if (containingClassType &&
+                    (0, types_1.isInstantiableClass)(containingClassType) &&
+                    types_1.ClassType.isSameGenericClass(containingClassType, classType)) {
+                    type = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _b === void 0 ? void 0 : _b.type;
+                    if (type && (0, types_1.isInstantiableClass)(memberInfo.classType)) {
+                        type = (0, typeUtils_1.partiallySpecializeType)(type, memberInfo.classType);
+                    }
+                    // If we're setting a class variable via a write through an object,
+                    // this is normally considered a type violation. But it is allowed
+                    // if the class variable is a descriptor object. In this case, we will
+                    // clear the flag that causes an error to be generated.
+                    if (usage.method === 'set' && memberInfo.symbol.isClassVar() && isAccessedThroughObject) {
+                        const selfClass = (selfType !== null && selfType !== void 0 ? selfType : memberName === '__new__') ? undefined : classType;
+                        const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
+                        if (typeResult) {
+                            if ((0, typeUtils_1.isDescriptorInstance)(typeResult.type, /* requireSetter */ true)) {
+                                type = typeResult.type;
+                                flags &= 128 /* DisallowClassVarWrites */;
                             }
                         }
                     }
-                    if (accessMethod) {
-                        let accessMethodType = getTypeOfMember(accessMethod);
-                        const argList = [
-                            {
-                                // Provide "obj" argument.
-                                argumentCategory: 0 /* Simple */,
-                                typeResult: {
-                                    type: types_1.ClassType.isClassProperty(lookupClass)
-                                        ? baseTypeClass
-                                        : isAccessedThroughObject
-                                            ? bindToType !== null && bindToType !== void 0 ? bindToType : types_1.ClassType.cloneAsInstance(baseTypeClass)
-                                            : types_1.NoneType.createInstance(),
-                                },
-                            },
-                        ];
-                        if (usage.method === 'get') {
-                            // Provide "owner" argument.
-                            argList.push({
-                                argumentCategory: 0 /* Simple */,
-                                typeResult: {
-                                    type: baseTypeClass,
-                                },
-                            });
-                        }
-                        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 & 1 /* AccessClassMembersOnly */) !== 0 &&
-                                types_1.ClassType.isProtocolClass(baseTypeClass)) {
-                                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 = memberInfo.classType;
-                                    }
-                                }
-                                else {
-                                    if ((0, types_1.isInstantiableClass)(accessMethod.classType)) {
-                                        bindToClass = accessMethod.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, baseTypeClass);
-                                        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 }));
-                                            }
-                                        }
-                                        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();
-                                }
-                                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 (!type) {
+                        type = types_1.UnknownType.create();
                     }
                 }
             }
-            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 (!type) {
+            let selfClass;
+            if (selfType) {
+                selfClass = (0, typeUtils_1.convertToInstantiable)(selfType);
+            }
+            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;
                 }
-                // 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)) {
-                    let effectiveBindToType = bindToType;
-                    if (bindToType && !(0, typeUtils_1.isInstantiableMetaclass)(baseTypeClass)) {
-                        // If bindToType is an instantiable class or TypeVar but we're targeting
-                        // an instance method (in a non-metaclass), we need to convert
-                        // the bindToType to an instance.
-                        const targetMethod = (0, types_1.isFunction)(concreteSubtype)
-                            ? concreteSubtype
-                            : concreteSubtype.overloads[0];
-                        if (types_1.FunctionType.isInstanceMethod(targetMethod) && !types_1.TypeBase.isInstance(bindToType)) {
-                            effectiveBindToType = (0, typeUtils_1.convertToInstance)(bindToType);
-                        }
-                    }
-                    // If the bind-to type is a specific class, add the "includeSubclasses" flag
-                    // to the type to indicate that it could be a subclass.
-                    if (effectiveBindToType && (0, types_1.isClass)(effectiveBindToType)) {
-                        effectiveBindToType = types_1.ClassType.cloneIncludeSubclasses(effectiveBindToType);
-                    }
-                    return bindFunctionToClassOrObjectWithErrors(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(baseTypeClass) : baseTypeClass, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, treatConstructorAsClassMember, effectiveBindToType);
+            }
+            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();
+            if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
+                isTypeIncomplete = true;
+            }
+        }
+        // Don't include variables within typed dict classes.
+        if ((0, types_1.isClass)(memberInfo.classType) && types_1.ClassType.isTypedDictClass(memberInfo.classType)) {
+            const typedDecls = memberInfo.symbol.getTypedDeclarations();
+            if (typedDecls.length > 0 && typedDecls[0].type === 1 /* Variable */) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
+                return undefined;
+            }
+        }
+        if (usage.method === 'get') {
+            // Mark the member accessed if it's not coming from a parent class.
+            if (errorNode &&
+                (0, types_1.isInstantiableClass)(memberInfo.classType) &&
+                types_1.ClassType.isSameGenericClass(memberInfo.classType, classType)) {
+                setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(errorNode), memberInfo.symbol, errorNode);
+            }
+            // Special-case `__init_subclass` and `__class_getitem__` because
+            // these are always treated as class methods even if they're not
+            // decorated as such.
+            if (memberName === '__init_subclass__' || memberName === '__class_getitem__') {
+                if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isClassMethod(type)) {
+                    type = types_1.FunctionType.cloneWithNewFlags(type, type.details.flags | 2 /* ClassMethod */);
                 }
             }
-            if (usage.method === 'set') {
-                if (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.isClassVar()) {
-                    if (flags & 16 /* DisallowClassVarWrites */) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberSetClassVar().format({ name: memberName }));
-                        isTypeValid = false;
-                        return undefined;
-                    }
+        }
+        // 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;
                 }
-                // 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;
-                    }
+                if (descResult.memberAccessDeprecationInfo) {
+                    memberAccessDeprecationInfo = descResult.memberAccessDeprecationInfo;
                 }
-                // 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;
+                if (descResult.typeErrors) {
+                    isDescriptorError = true;
                 }
-                let enforceTargetType = false;
-                if (memberInfo && memberInfo.symbol.hasTypedDeclarations()) {
-                    // If the member has a declared type, we will enforce it.
-                    enforceTargetType = true;
+                if (descResult.isDescriptorApplied) {
+                    isDescriptorApplied = 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;
+                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;
                 }
             }
-            return subtype;
+            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 (!isTypeValid) {
-            return undefined;
+        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,
+            type,
+            isTypeIncomplete,
+            isDescriptorError,
+            isClassMember: !memberInfo.isInstanceMember,
+            isClassVar: memberInfo.isClassVar,
+            classType: memberInfo.classType,
+            isAsymmetricAccessor,
+            memberAccessDeprecationInfo,
+        };
+    }
+    // Applies descriptor access methods "__get__", "__set__", or "__delete__"
+    // 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 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;
+        if (usage.method === 'set' && (0, types_1.isClass)(methodClassType)) {
+            if (isAsymmetricDescriptorClass(methodClassType)) {
+                isAsymmetricAccessor = true;
+            }
+        }
+        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 (!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),
+                }));
+            }
+            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: 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 };
+            }
         }
-        return { type, isAsymmetricAccessor, memberAccessDeprecationInfo };
+        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;
@@ -4366,14 +4202,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return isAsymmetric;
     }
     // Applies the __getattr__, __setattr__ or __delattr__ method if present.
-    function applyAttributeAccessOverride(classType, errorNode, usage, memberName) {
+    // 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;
-            // See if the class has a "__getattribute__" or "__getattr__" method.
-            // If so, arbitrary members are supported.
-            return (_a = getTypeOfClassMember(errorNode, classType, name, { method: 'get' }, 
-            /* diag */ undefined, 8 /* SkipObjectBaseClass */ | 128 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
+            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;
         };
         let accessMemberType;
         if (usage.method === 'get') {
@@ -4386,51 +4224,48 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, debug_1.assert)(usage.method === 'del');
             accessMemberType = getAttributeAccessMember('__delattr__');
         }
-        if (accessMemberType) {
-            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 "self" argument.
-                    argumentCategory: 0 /* Simple */,
-                    typeResult: { type: types_1.ClassType.cloneAsInstance(classType) },
-                },
-                {
-                    // Provide "name" argument.
-                    argumentCategory: 0 /* Simple */,
-                    typeResult: { type: nameLiteralType },
+        if (!accessMemberType) {
+            return undefined;
+        }
+        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({
+                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(),
+                    isIncomplete: !!((_d = usage.setType) === null || _d === void 0 ? void 0 : _d.isIncomplete),
                 },
-            ];
-            if (usage.method === 'set') {
-                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(),
-                        isIncomplete: !!((_d = usage.setType) === null || _d === void 0 ? void 0 : _d.isIncomplete),
-                    },
-                });
-            }
-            if ((0, types_1.isFunction)(accessMemberType) || (0, types_1.isOverloadedFunction)(accessMemberType)) {
-                const boundMethodType = bindFunctionToClassOrObjectWithErrors(classType, accessMemberType, classType, errorNode);
-                if (boundMethodType && ((0, types_1.isFunction)(boundMethodType) || (0, types_1.isOverloadedFunction)(boundMethodType))) {
-                    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(boundMethodType));
-                    const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
-                    /* skipUnknownArgCheck */ true);
-                    let isAsymmetricAccessor = false;
-                    if (usage.method === 'set') {
-                        isAsymmetricAccessor = isClassWithAsymmetricAttributeAccessor(classType);
-                    }
-                    return {
-                        type: (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create(),
-                        isAsymmetricAccessor,
-                    };
-                }
+            });
+        }
+        if (!(0, types_1.isFunction)(accessMemberType) && !(0, types_1.isOverloadedFunction)(accessMemberType)) {
+            if ((0, types_1.isAnyOrUnknown)(accessMemberType)) {
+                return { type: accessMemberType };
             }
+            // TODO - emit an error for this condition.
+            return undefined;
         }
-        return undefined;
+        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(accessMemberType));
+        const callResult = validateCallArguments(errorNode, argList, { type: accessMemberType }, typeVarContext, 
+        /* skipUnknownArgCheck */ true);
+        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,
+        };
     }
     function getTypeOfIndex(node, flags = 0 /* None */) {
         const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* IndexBaseDefaults */);
@@ -4639,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}`,
@@ -4757,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;
@@ -4786,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 = getTypeOfClassMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
-                    /* usage */ undefined, 
-                    /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 64 /* ConsiderMetaclassOnly */);
+                    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({
@@ -4876,6 +4710,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return result.type;
             }
+            if ((0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
+                if (!isIncomplete) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalSubscript, diagnosticRules_1.DiagnosticRule.reportOptionalSubscript, localize_1.Localizer.Diagnostic.noneNotSubscriptable(), node.baseExpression);
+                }
+                return types_1.UnknownType.create();
+            }
             if ((0, types_1.isClassInstance)(concreteSubtype)) {
                 const typeResult = getTypeOfIndexedObjectOrClass(node, concreteSubtype, usage);
                 if (typeResult.isIncomplete) {
@@ -4886,10 +4726,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isNever)(concreteSubtype) || (0, types_1.isUnbound)(concreteSubtype)) {
                 return types_1.NeverType.createNever();
             }
-            if ((0, types_1.isNoneInstance)(concreteSubtype) && !isIncomplete) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalSubscript, diagnosticRules_1.DiagnosticRule.reportOptionalSubscript, localize_1.Localizer.Diagnostic.noneNotSubscriptable(), node.baseExpression);
-                return types_1.UnknownType.create();
-            }
             if (!isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSubscriptable().format({ type: printType(concreteSubtype) }), node.baseExpression);
@@ -4952,7 +4788,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
         }
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-            if (subtype.category === 5 /* Function */) {
+            if (subtype.category === 4 /* Function */) {
                 if (subtype.specializedTypes) {
                     subtype.specializedTypes.parameterTypes.forEach((paramType) => {
                         updateUsageVarianceForType(paramType, 4 /* Contravariant */);
@@ -4963,7 +4799,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
-            else if (subtype.category === 7 /* Class */) {
+            else if (subtype.category === 6 /* Class */) {
                 if (subtype.typeArguments) {
                     // If the class includes type parameters that uses auto variance,
                     // compute the calculated variance.
@@ -5012,7 +4848,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfIndexedObjectOrClass(node, baseType, usage) {
-        var _a, _b, _c, _d, _e, _f;
+        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);
@@ -5021,13 +4857,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const magicMethodName = getIndexAccessMagicMethodName(usage);
-        const itemMethodType = (0, types_1.isClassInstance)(baseType)
-            ? (_a = getTypeOfObjectMember(node, baseType, magicMethodName, 
-            /* usage */ undefined, 
-            /* diag */ undefined, 128 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type
-            : (_b = getTypeOfClassMember(node, baseType, magicMethodName, 
-            /* usage */ undefined, 
-            /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 64 /* ConsiderMetaclassOnly */)) === null || _b === void 0 ? void 0 : _b.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({
@@ -5156,7 +4986,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             },
         ];
         if (usage.method === 'set') {
-            let setType = (_d = (_c = usage.setType) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : 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;
@@ -5167,7 +4997,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argumentCategory: 0 /* Simple */,
                 typeResult: {
                     type: setType,
-                    isIncomplete: !!((_e = usage.setType) === null || _e === void 0 ? void 0 : _e.isIncomplete),
+                    isIncomplete: !!((_c = usage.setType) === null || _c === void 0 ? void 0 : _c.isIncomplete),
                 },
             });
         }
@@ -5199,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)) {
@@ -5217,7 +5047,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         callResult = validateCallArguments(node, argList, { type: itemMethodType });
         return {
-            type: (_f = callResult.returnType) !== null && _f !== void 0 ? _f : types_1.UnknownType.create(),
+            type: (_d = callResult.returnType) !== null && _d !== void 0 ? _d : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
@@ -5807,7 +5637,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addInformation(localize_1.Localizer.Diagnostic.revealLocalsNone(), node);
         }
-        return types_1.NoneType.createInstance();
+        return getNoneType();
     }
     function getTypeOfSuperCall(node) {
         var _a;
@@ -5832,6 +5662,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             if (enclosingClassType) {
                 targetClassType = enclosingClassType !== null && enclosingClassType !== void 0 ? enclosingClassType : types_1.UnknownType.create();
+                // Zero-argument forms of super are not allowed within static methods.
+                // This results in a runtime exception.
+                if (enclosingFunction) {
+                    const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
+                    /* isInClass */ true);
+                    if (((functionInfo === null || functionInfo === void 0 ? void 0 : functionInfo.flags) & 4 /* StaticMethod */) !== 0) {
+                        addError(localize_1.Localizer.Diagnostic.superCallZeroArgFormStaticMethod(), node.leftExpression);
+                        targetClassType = types_1.UnknownType.create();
+                    }
+                }
             }
             else {
                 addError(localize_1.Localizer.Diagnostic.superCallZeroArgForm(), node.leftExpression);
@@ -5893,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
@@ -5916,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;
@@ -5927,8 +5782,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: resultIsInstance
                         ? types_1.ClassType.cloneAsInstance(lookupResults.classType)
                         : lookupResults.classType,
-                    bindToType: bindToType
-                        ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, !resultIsInstance), bindToType.condition)
+                    bindToSelfType: bindToType
+                        ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, /* isClsParam */ false), bindToType.condition)
                         : undefined,
                 };
             }
@@ -6418,7 +6273,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }, {
                 allowDiagnostics: true,
             });
-        });
+        }, 
+        /* sortSubtypes */ true);
         // If we ended up with a "Never" type because all code paths returned
         // undefined due to argument errors, transform the result into an Unknown
         // to avoid subsequent false positives.
@@ -6435,7 +6291,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function validateCallArgumentsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
         switch (expandedCallType.category) {
-            case 4 /* Never */:
+            case 3 /* Never */:
             case 1 /* Unknown */:
             case 2 /* Any */: {
                 // Touch all of the args so they're marked accessed. Don't bother
@@ -6450,37 +6306,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return { returnType: expandedCallType };
             }
-            case 5 /* Function */: {
+            case 4 /* Function */: {
                 return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
             }
-            case 6 /* OverloadedFunction */: {
+            case 5 /* OverloadedFunction */: {
                 return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
             }
-            case 7 /* Class */: {
+            case 6 /* Class */: {
+                if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalCall, diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.Localizer.Diagnostic.noneNotCallable(), errorNode);
+                    return { argumentErrors: true };
+                }
                 if (types_1.TypeBase.isInstantiable(expandedCallType)) {
                     return validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext);
                 }
                 return validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
             }
-            case 3 /* None */: {
-                if (types_1.TypeBase.isInstantiable(expandedCallType)) {
-                    if (noneType && (0, types_1.isInstantiableClass)(noneType)) {
-                        const callResult = validateCallForInstantiableClass(errorNode, argList, noneType, noneType, skipUnknownArgCheck, inferenceContext);
-                        return { ...callResult, returnType: types_1.NoneType.createInstance() };
-                    }
-                    return { returnType: types_1.NoneType.createInstance() };
-                }
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalCall, diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.Localizer.Diagnostic.noneNotCallable(), errorNode);
-                return { argumentErrors: true };
-            }
             // TypeVars should have been expanded in most cases,
             // but we still need to handle the case of Type[T] where
             // T is a constrained type that contains a union. We also
             // need to handle recursive type aliases.
-            case 10 /* TypeVar */: {
+            case 9 /* TypeVar */: {
                 return validateCallArguments(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
             }
-            case 8 /* Module */: {
+            case 7 /* Module */: {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleNotCallable(), errorNode);
                 return { argumentErrors: true };
             }
@@ -6611,7 +6460,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const returnType = (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
                         if ((0, types_1.isClassInstance)(subtype) ||
                             ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstance(subtype)) ||
-                            (0, types_1.isNoneInstance)(subtype)) {
+                            (0, typeUtils_1.isNoneInstance)(subtype)) {
                             return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
                         }
                         else if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
@@ -6655,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, 
@@ -6756,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, 128 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === 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) &&
@@ -6847,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;
@@ -6959,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;
@@ -7021,8 +6876,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // with a ParamSpec and a Concatenate operator. PEP 612 indicates that
                 // all positional parameters specified in the Concatenate must be
                 // filled explicitly.
-                if (typeResult.type.details.paramSpec && paramIndex < positionParamLimitIndex) {
-                    if ((0, types_1.isTypeVar)(argTypeResult.type) && argTypeResult.type.paramSpecAccess === 'args') {
+                if (paramIndex < positionParamLimitIndex) {
+                    if ((0, types_1.isTypeVar)(argTypeResult.type) &&
+                        argTypeResult.type.paramSpecAccess === 'args' &&
+                        paramDetails.params[paramIndex].param.category !== 1 /* ArgsList */) {
                         if (!isDiagnosticSuppressedForNode(errorNode)) {
                             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
                                 ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
@@ -7070,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;
                     }
@@ -7104,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,
@@ -7407,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);
@@ -7423,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.
@@ -7472,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,
                                 });
                             }
                         }
@@ -8140,6 +8000,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { argumentErrors: paramSpecArgResult.argumentErrors, typeVarContexts };
     }
     function validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext, signatureTracker) {
+        var _a;
         let paramSpecType = typeVarContext.getParamSpecType(paramSpec);
         if (!paramSpecType) {
             paramSpecType = (0, typeUtils_1.convertTypeToParamSpecValue)(paramSpec);
@@ -8162,8 +8023,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (functionType.details.paramSpec &&
             functionType.details.parameters.length === 0 &&
             (0, types_1.isTypeSame)(functionType.details.paramSpec, paramSpec)) {
-            // TODO - need to perform additional validation here.
-            return { argumentErrors: false, typeVarContexts: [srcTypeVarContext] };
+            // If there are any arguments other than *args: P.args or **kwargs: P.kwargs,
+            // report an error.
+            let sawArgs = false;
+            let sawKwargs = false;
+            let argumentErrors = false;
+            let argErrorNode;
+            for (const arg of argList) {
+                const argType = (_a = getTypeOfArgument(arg)) === null || _a === void 0 ? void 0 : _a.type;
+                const isArgTypeCompatible = argType && ((0, types_1.isTypeSame)(argType, paramSpec) || (0, types_1.isAnyOrUnknown)(argType));
+                if (arg.argumentCategory === 1 /* UnpackedList */ && !sawArgs && isArgTypeCompatible) {
+                    sawArgs = true;
+                }
+                else if (arg.argumentCategory === 2 /* UnpackedDictionary */ &&
+                    !sawKwargs &&
+                    isArgTypeCompatible) {
+                    sawKwargs = true;
+                }
+                else {
+                    argErrorNode = argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : arg.valueExpression;
+                    argumentErrors = true;
+                }
+            }
+            if (!sawArgs || !sawKwargs) {
+                argumentErrors = true;
+            }
+            if (argumentErrors) {
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecArgsMissing().format({
+                    type: printType(functionType.details.paramSpec),
+                }), argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : errorNode);
+            }
+            return { argumentErrors, typeVarContexts: [srcTypeVarContext] };
         }
         const result = validateFunctionArgumentTypes(errorNode, matchResults, srcTypeVarContext, signatureTracker);
         return { argumentErrors: !!result.argumentErrors, typeVarContexts: [srcTypeVarContext] };
@@ -8327,7 +8217,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 if ((0, types_1.isClassInstance)(argType)) {
-                    const callMember = (0, typeUtils_1.lookUpObjectMember)(argType, '__call__', 8 /* SkipInstanceVariables */);
+                    const callMember = (0, typeUtils_1.lookUpObjectMember)(argType, '__call__', 16 /* SkipInstanceMembers */);
                     if (callMember) {
                         const memberType = getTypeOfMember(callMember);
                         if ((0, types_1.isOverloadedFunction)(memberType)) {
@@ -8891,7 +8781,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.ClassType.cloneAsInstance(baseClass),
                 hasDeclaredType: true,
             });
-            initType.details.declaredReturnType = types_1.NoneType.createInstance();
+            initType.details.declaredReturnType = getNoneType();
             classType.details.fields.set('__init__', symbol_1.Symbol.createWithType(4 /* ClassMember */, initType));
             // Synthesize a trivial __new__ method.
             const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
@@ -8938,10 +8828,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfConstant(node, flags) {
         let type;
         if (node.constType === 26 /* None */) {
-            type =
-                (flags & 128 /* ExpectingInstantiableType */) !== 0
-                    ? types_1.NoneType.createType()
-                    : types_1.NoneType.createInstance();
+            type = (flags & 128 /* ExpectingInstantiableType */) !== 0 ? noneClassType : noneType;
         }
         else if (node.constType === 33 /* True */ ||
             node.constType === 15 /* False */ ||
@@ -8958,46 +8845,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        if (!type) {
-            return undefined;
-        }
-        return { type };
+        return { type: type !== null && type !== void 0 ? type : types_1.UnknownType.create() };
     }
-    function getTypeOfMagicMethodReturn(objType, args, magicMethodName, errorNode, inferenceContext) {
+    function getTypeOfMagicMethodCall(objType, methodName, argList, errorNode, inferenceContext) {
         let magicMethodSupported = true;
         // Create a helper lambda for object subtypes.
         const handleSubtype = (subtype) => {
-            var _a, _b;
             let magicMethodType;
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
-            if ((0, types_1.isClassInstance)(concreteSubtype)) {
-                magicMethodType = (_a = getTypeOfObjectMember(errorNode, concreteSubtype, magicMethodName, 
-                /* usage */ undefined, 
-                /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === null || _a === void 0 ? void 0 : _a.type;
-            }
-            else if ((0, types_1.isInstantiableClass)(concreteSubtype)) {
-                magicMethodType = (_b = getTypeOfClassMember(errorNode, concreteSubtype, magicMethodName, 
-                /* usage */ undefined, 
-                /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 64 /* ConsiderMetaclassOnly */)) === null || _b === void 0 ? void 0 : _b.type;
+            if ((0, types_1.isClass)(concreteSubtype)) {
+                magicMethodType = getBoundMagicMethod(concreteSubtype, methodName, subtype);
             }
             if (magicMethodType) {
-                const functionArgs = args.map((arg) => {
+                const functionArgs = argList.map((arg) => {
                     return {
                         argumentCategory: 0 /* Simple */,
                         typeResult: arg,
                     };
                 });
                 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);
                     });
@@ -9017,13 +8895,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClassInstance)(subtype) || (0, types_1.isInstantiableClass)(subtype) || (0, types_1.isTypeVar)(subtype)) {
                 return handleSubtype(subtype);
             }
-            if ((0, types_1.isNoneInstance)(subtype)) {
+            if ((0, typeUtils_1.isNoneInstance)(subtype)) {
                 if (objectType && (0, types_1.isClassInstance)(objectType)) {
                     // Use 'object' for 'None'.
                     return handleSubtype(objectType);
                 }
             }
-            if ((0, types_1.isNoneTypeClass)(subtype)) {
+            if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
                 if (typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
                     // Use 'type' for 'type[None]'.
                     return handleSubtype(types_1.ClassType.cloneAsInstance(typeClassType));
@@ -9640,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);
                     }
@@ -9675,11 +9553,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Pre-cache the incomplete function type in case the evaluation of the
         // lambda depends on itself.
         writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
+        // We assume for simplicity that the parameter signature of the lambda is
+        // the same as the expected type. If this isn't the case, we'll use
+        // object for any lambda parameters that don't match. We could make this
+        // more sophisticated in the future, but it becomes very complex to handle
+        // all of the permutations.
+        let sawParamMismatch = false;
         node.parameters.forEach((param, index) => {
             let paramType;
-            if (expectedParamDetails) {
+            if (expectedParamDetails && !sawParamMismatch) {
                 if (index < expectedParamDetails.params.length) {
-                    paramType = expectedParamDetails.params[index].type;
+                    const expectedParam = expectedParamDetails.params[index];
+                    // If the parameter category matches and both of the parameters are
+                    // either separators (/ or *) or not separators, copy the type
+                    // from the expected parameter.
+                    if (expectedParam.param.category === param.category && !param.name === !expectedParam.param.name) {
+                        paramType = expectedParam.type;
+                    }
+                    else {
+                        sawParamMismatch = true;
+                    }
                 }
                 else if (param.defaultValue) {
                     // If the lambda param has a default value but there is no associated
@@ -9789,8 +9682,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedElementType;
         if (inferenceContext) {
-            expectedElementType = (_a = getTypeOfIterator({ type: inferenceContext.expectedType }, isAsync, 
-            /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
+            expectedElementType = (_a = getTypeOfIterator({ type: inferenceContext.expectedType }, isAsync, node, 
+            /* emitNotIterableError */ false)) === null || _a === void 0 ? void 0 : _a.type;
         }
         const elementTypeResult = getElementTypeFromListComprehension(node, expectedElementType);
         if (elementTypeResult.isIncomplete) {
@@ -9810,9 +9703,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
         if (builtInIteratorType && (0, types_1.isInstantiableClass)(builtInIteratorType)) {
-            type = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(builtInIteratorType, isAsync
-                ? [elementType, types_1.NoneType.createInstance()]
-                : [elementType, types_1.NoneType.createInstance(), types_1.NoneType.createInstance()], 
+            type = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(builtInIteratorType, isAsync ? [elementType, getNoneType()] : [elementType, getNoneType(), getNoneType()], 
             /* isTypeArgumentExplicit */ true));
         }
         return { type, isIncomplete, typeErrors };
@@ -10141,7 +10032,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addExpectedClassDiagnostic(typeArg0Type, typeArgs[0].node);
             typeArg0Type = types_1.UnknownType.create();
         }
-        const optionalType = (0, types_1.combineTypes)([typeArg0Type, types_1.NoneType.createType()]);
+        const optionalType = (0, types_1.combineTypes)([typeArg0Type, noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create()]);
         if ((0, types_1.isUnion)(optionalType)) {
             types_1.TypeBase.setSpecialForm(optionalType);
         }
@@ -10204,7 +10095,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type = cloneBuiltinClassWithLiteral(node, 'bool', false);
                 }
                 else if (itemExpr.constType === 26 /* None */) {
-                    type = types_1.NoneType.createType();
+                    type = noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create();
                 }
             }
             else if (itemExpr.nodeType === 55 /* UnaryOperation */ &&
@@ -10228,7 +10119,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     let isLiteralType = true;
                     (0, typeUtils_1.doForEachSubtype)(exprType.type, (subtype) => {
                         if (!(0, types_1.isInstantiableClass)(subtype) || subtype.literalValue === undefined) {
-                            if (!(0, types_1.isNoneTypeClass)(subtype)) {
+                            if (!(0, typeUtils_1.isNoneTypeClass)(subtype)) {
                                 isLiteralType = false;
                             }
                         }
@@ -10510,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) {
@@ -10639,7 +10531,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // is allowed if it's an unpacked variadic type var or tuple. None is also allowed
         // since it is used to define NoReturn in typeshed stubs).
         if (types.length === 1) {
-            if (!(0, types_1.isVariadicTypeVar)(types[0]) && !(0, types_1.isUnpacked)(types[0]) && !(0, types_1.isNoneInstance)(types[0])) {
+            if (!(0, types_1.isVariadicTypeVar)(types[0]) && !(0, types_1.isUnpacked)(types[0]) && !(0, typeUtils_1.isNoneInstance)(types[0])) {
                 addError(localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
             }
         }
@@ -10696,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.
@@ -10712,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;
@@ -10988,11 +10882,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeAliasNameNode) {
                     // If this was a speculative type alias, it becomes a real type alias
                     // only if the evaluated type is an instantiable type.
-                    if (!isSpeculativeTypeAlias ||
-                        (types_1.TypeBase.isInstantiable(rightHandType) && !(0, types_1.isUnknown)(rightHandType))) {
+                    if (!isSpeculativeTypeAlias || isLegalImplicitTypeAliasType(rightHandType)) {
                         // 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,
@@ -11115,6 +11009,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return `__type_of_${paramName}`;
     }
     function getTypeOfClass(node) {
+        initializedBasicTypes(node);
         // Is this type already cached?
         const cachedClassType = readTypeCache(node.name, 0 /* None */);
         if (cachedClassType) {
@@ -11135,7 +11030,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((scope === null || scope === void 0 ? void 0 : scope.type) === 4 /* Builtin */ ||
             fileInfo.isTypingStubFile ||
             fileInfo.isTypingExtensionsStubFile ||
-            fileInfo.isBuiltInStubFile) {
+            fileInfo.isBuiltInStubFile ||
+            fileInfo.isTypeshedStubFile) {
             classFlags |= 1 /* BuiltInClass */;
             if (fileInfo.isTypingExtensionsStubFile) {
                 classFlags |= 65536 /* TypingExtensionClass */;
@@ -11443,7 +11339,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 classType.details.fields.set('__hash__', symbol_1.Symbol.createWithType(4 /* ClassMember */ |
                     128 /* ClassVar */ |
                     64 /* IgnoredForProtocolMatch */ |
-                    4096 /* IgnoredForOverrideChecks */, types_1.NoneType.createInstance()));
+                    4096 /* IgnoredForOverrideChecks */, getNoneType()));
             }
             // Determine whether the class's instance variables are constrained
             // to those defined by __slots__. We need to do this prior to dataclass
@@ -11707,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
@@ -11875,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 = [];
@@ -11888,72 +11786,91 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
             }
         });
-        const errorNode = argList.length > 0 ? argList[0].node.name : node.name;
-        const initSubclassMethodInfo = getTypeOfClassMemberName(errorNode, classType, 
-        /* isAccessedThroughObject */ false, '__init_subclass__', { method: 'get' }, 
-        /* diag */ undefined, 1 /* AccessClassMembersOnly */ |
-            8 /* SkipObjectBaseClass */ |
-            256 /* SkipOriginalClass */, classType);
-        if (initSubclassMethodInfo) {
-            const initSubclassMethodType = initSubclassMethodInfo.type;
-            if (initSubclassMethodType) {
-                validateCallArguments(errorNode, argList, { type: initSubclassMethodType }, 
-                /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(types_1.NoneType.createInstance()));
-            }
-        }
-        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__', 64 /* 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);
                         }
                     }
                 }
@@ -11967,6 +11884,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
     }
     function getTypeOfFunction(node) {
+        initializedBasicTypes(node);
         // Is this predecorated function type cached?
         let functionType = readTypeCache(node.name, 0 /* None */);
         if (functionType) {
@@ -12116,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;
@@ -12329,7 +12247,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Special-case the __init__ method, which is commonly left without
                 // an annotated return type, but we can assume it returns None.
                 if (node.name.value === '__init__') {
-                    functionType.details.declaredReturnType = types_1.NoneType.createInstance();
+                    functionType.details.declaredReturnType = getNoneType();
                 }
                 else {
                     functionType.details.declaredReturnType = types_1.UnknownType.create();
@@ -12422,7 +12340,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             param.defaultValue.constType === 26 /* None */ &&
             !(0, typeUtils_1.isOptionalType)(type) &&
             !AnalyzerNodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
-            return (0, types_1.combineTypes)([type, types_1.NoneType.createInstance()]);
+            return (0, types_1.combineTypes)([type, getNoneType()]);
         }
         return type;
     }
@@ -12482,7 +12400,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // whose name starts with an underscore)? If so, we will assume that the
             // value is a singleton sentinel. The actual supported type is going to be
             // a union of this type and Unknown.
-            if ((0, types_1.isNoneInstance)(defaultValueType) ||
+            if ((0, typeUtils_1.isNoneInstance)(defaultValueType) ||
                 ((0, types_1.isClassInstance)(defaultValueType) && (0, symbolNameUtils_1.isPrivateOrProtectedName)(defaultValueType.details.name))) {
                 inferredParamType = (0, types_1.combineTypes)([defaultValueType, types_1.UnknownType.create()]);
             }
@@ -12680,13 +12598,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         inferredReturnTypes.push(returnType);
                                     }
                                     else {
-                                        inferredReturnTypes.push(types_1.NoneType.createInstance());
+                                        inferredReturnTypes.push(getNoneType());
                                     }
                                 }
                             });
                         }
                         if (!functionNeverReturns && implicitlyReturnsNone) {
-                            inferredReturnTypes.push(types_1.NoneType.createInstance());
+                            inferredReturnTypes.push(getNoneType());
                         }
                         inferredReturnType = (0, types_1.combineTypes)(inferredReturnTypes);
                         // Remove any unbound values since those would generate an exception
@@ -12728,14 +12646,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                             inferredYieldTypes.push(yieldType !== null && yieldType !== void 0 ? yieldType : types_1.UnknownType.create());
                                         }
                                         else {
-                                            inferredYieldTypes.push(types_1.NoneType.createInstance());
+                                            inferredYieldTypes.push(getNoneType());
                                         }
                                     }
                                 }
                             });
                         }
                         if (inferredYieldTypes.length === 0) {
-                            inferredYieldTypes.push(types_1.NoneType.createInstance());
+                            inferredYieldTypes.push(getNoneType());
                         }
                         const inferredYieldType = (0, types_1.combineTypes)(inferredYieldTypes);
                         // Inferred yield types need to be wrapped in a Generator or
@@ -12749,7 +12667,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // This eliminates any "partially unknown" errors in strict mode
                             // in the common case.
                             const sendType = isYieldResultUsed ? types_1.UnknownType.create() : types_1.AnyType.create();
-                            typeArgs.push(inferredYieldType, sendType, (0, types_1.isNever)(inferredReturnType) ? types_1.NoneType.createInstance() : inferredReturnType);
+                            typeArgs.push(inferredYieldType, sendType, (0, types_1.isNever)(inferredReturnType) ? getNoneType() : inferredReturnType);
                             if (useAwaitableGenerator) {
                                 typeArgs.push(types_1.AnyType.create());
                             }
@@ -12866,7 +12784,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, typeUtils_1.isOptionalType)(exprType)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             addDiagnostic(fileInfo.diagnosticRuleSet.reportOptionalContextManager, diagnosticRules_1.DiagnosticRule.reportOptionalContextManager, localize_1.Localizer.Diagnostic.noneNotUsableWith(), node.expression);
-            exprType = (0, types_1.removeNoneFromUnion)(exprType);
+            exprType = (0, typeUtils_1.removeNoneFromUnion)(exprType);
         }
         // Verify that the target has an __enter__ or __aenter__ method defined.
         const enterMethodName = isAsync ? '__aenter__' : '__enter__';
@@ -12877,7 +12795,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             const additionalHelp = new diagnostic_1.DiagnosticAddendum();
             if ((0, types_1.isClass)(subtype)) {
-                let enterType = getTypeOfMagicMethodReturn(subtype, [], enterMethodName, node.expression, 
+                let enterType = getTypeOfMagicMethodCall(subtype, enterMethodName, [], node.expression, 
                 /* inferenceContext */ undefined);
                 if (enterType) {
                     // For "async while", an implicit "await" is performed.
@@ -12887,7 +12805,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return enterType;
                 }
                 if (!isAsync) {
-                    if (getTypeOfMagicMethodReturn(subtype, [], '__aenter__', node.expression, 
+                    if (getTypeOfMagicMethodCall(subtype, '__aenter__', [], node.expression, 
                     /* inferenceContext */ undefined)) {
                         additionalHelp.addMessage(localize_1.Localizer.DiagnosticAddendum.asyncHelp());
                     }
@@ -12907,7 +12825,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if ((0, types_1.isClass)(subtype)) {
                 const anyArg = { type: types_1.AnyType.create() };
-                const exitType = getTypeOfMagicMethodReturn(subtype, [anyArg, anyArg, anyArg], exitMethodName, node.expression, 
+                const exitType = getTypeOfMagicMethodCall(subtype, exitMethodName, [anyArg, anyArg, anyArg], node.expression, 
                 /* inferenceContext */ undefined);
                 if (exitType) {
                     return;
@@ -14001,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),
@@ -14042,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) {
@@ -14345,7 +14265,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((0, types_1.isInstantiableClass)(subtype)) {
                         // Try to find a member that has a declared type. If so, that
                         // overrides any inferred types.
-                        let member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName, 32 /* DeclaredTypesOnly */);
+                        let member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName, 64 /* DeclaredTypesOnly */);
                         if (!member) {
                             member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
                         }
@@ -14362,7 +14282,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if ((0, types_1.isClassInstance)(subtype)) {
                         // Try to find a member that has a declared type. If so, that
                         // overrides any inferred types.
-                        let member = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName, 32 /* DeclaredTypesOnly */);
+                        let member = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName, 64 /* DeclaredTypesOnly */);
                         if (!member) {
                             member = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
                         }
@@ -14427,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, 8 /* 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) {
@@ -14492,7 +14411,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return { type: strType };
                     }
                     if (declaration.intrinsicType === 'str | None') {
-                        return { type: (0, types_1.combineTypes)([strType, types_1.NoneType.createInstance()]) };
+                        return { type: (0, types_1.combineTypes)([strType, getNoneType()]) };
                     }
                     if (declaration.intrinsicType === 'int') {
                         return { type: intType };
@@ -14810,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;
@@ -14828,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) {
@@ -14840,9 +14762,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If this was a speculative type alias, it becomes a real type alias only
                 // in the event that its inferred type is instantiable or explicitly Any
                 // (but not an ellipsis).
-                if (types_1.TypeBase.isInstantiable(inferredType) &&
-                    !(0, types_1.isUnknown)(inferredType) &&
-                    !(0, typeUtils_1.isEllipsisType)(inferredType)) {
+                if (isLegalImplicitTypeAliasType(inferredType)) {
                     inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.typeAliasName, resolvedDecl.node, 
                     /* isPep695Syntax */ false);
                     isUnambiguousType = true;
@@ -15311,7 +15231,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Don't bother inferring the return type of __init__ because it's
             // always None.
             if (types_1.FunctionType.isInstanceMethod(type) && type.details.name === '__init__') {
-                returnType = types_1.NoneType.createInstance();
+                returnType = getNoneType();
             }
             else if (type.details.declaration) {
                 const functionNode = type.details.declaration.node;
@@ -15602,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)),
@@ -15855,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.
@@ -15910,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;
     }
@@ -16274,23 +16193,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isUnion)(destType)) {
             return assignToUnionType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, originalFlags, recursionCount);
         }
-        if ((0, types_1.isNoneInstance)(destType)) {
-            if ((0, types_1.isNoneInstance)(srcType)) {
+        if ((0, typeUtils_1.isNoneInstance)(destType)) {
+            if ((0, typeUtils_1.isNoneInstance)(srcType)) {
                 return true;
             }
             if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'NoneType')) {
                 return true;
             }
         }
-        if ((0, types_1.isNoneTypeClass)(destType)) {
-            if ((0, types_1.isNoneTypeClass)(srcType)) {
+        if ((0, typeUtils_1.isNoneTypeClass)(destType)) {
+            if ((0, typeUtils_1.isNoneTypeClass)(srcType)) {
                 return true;
             }
             if ((0, types_1.isInstantiableClass)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'NoneType')) {
                 return true;
             }
         }
-        // Is the src a specialized "Type" object?
+        // Is the src a specialized "type" object?
         if ((0, types_1.isClassInstance)(expandedSrcType) && types_1.ClassType.isBuiltIn(expandedSrcType, 'type')) {
             const srcTypeArgs = expandedSrcType.typeArguments;
             let typeTypeArg;
@@ -16342,6 +16261,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
+            else if ((0, types_1.isClassInstance)(expandedSrcType) && (0, typeUtils_1.isMetaclassInstance)(expandedSrcType)) {
+                // If the source is a metaclass instance, verify that it's compatible with
+                // the metaclass of the instantiable dest type.
+                const destMetaclass = destType.details.effectiveMetaclass;
+                if (destMetaclass && (0, types_1.isInstantiableClass)(destMetaclass)) {
+                    if (assignClass(types_1.ClassType.cloneAsInstance(destMetaclass), expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                    /* reportErrorsUsingObjType */ false)) {
+                        return true;
+                    }
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                    return false;
+                }
+            }
         }
         if ((0, types_1.isClassInstance)(destType)) {
             // Is the dest a specialized "Type" object?
@@ -16435,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;
@@ -16460,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;
                 }
@@ -16560,13 +16492,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Are we trying to assign None to a protocol?
-        if ((0, types_1.isNoneInstance)(srcType) && (0, types_1.isClassInstance)(destType) && types_1.ClassType.isProtocolClass(destType)) {
-            if (noneType && (0, types_1.isInstantiableClass)(noneType)) {
-                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), noneType, diag, destTypeVarContext, srcTypeVarContext, flags, 
-                /* treatSourceAsInstantiable */ false, recursionCount);
+        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), types_1.ClassType.cloneAsInstance(noneClassType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
             }
         }
-        if ((0, types_1.isNoneInstance)(destType)) {
+        if ((0, typeUtils_1.isNoneInstance)(destType)) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.assignToNone());
             return false;
         }
@@ -16823,7 +16754,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // match we find because we may need to match TypeVars in other
             // subtypes. We special-case "None" so we can handle Optional[T]
             // without matching the None to the type var.
-            if ((0, types_1.isNoneInstance)(srcType) && (0, typeUtils_1.isOptionalType)(destType)) {
+            if ((0, typeUtils_1.isNoneInstance)(srcType) && (0, typeUtils_1.isOptionalType)(destType)) {
                 foundMatch = true;
             }
             else {
@@ -16952,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);
         }
@@ -17038,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;
         }
@@ -17106,15 +17040,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         let canAssign = true;
         const checkReturnType = (flags & 32 /* SkipFunctionReturnTypeCheck */) === 0;
+        const reverseMatching = (flags & 2 /* ReverseTypeVarMatching */) !== 0;
         flags &= ~32 /* SkipFunctionReturnTypeCheck */;
         destType = (0, typeUtils_1.removeParamSpecVariadicsFromFunction)(destType);
         srcType = (0, typeUtils_1.removeParamSpecVariadicsFromFunction)(srcType);
         const destParamDetails = (0, parameterUtils_1.getParameterListDetails)(destType);
         const srcParamDetails = (0, parameterUtils_1.getParameterListDetails)(srcType);
-        adjustSourceParamDetailsForDestVariadic(srcParamDetails, destParamDetails);
-        const targetIncludesParamSpec = (flags & 2 /* ReverseTypeVarMatching */) !== 0
-            ? !!srcType.details.paramSpec
-            : !!destType.details.paramSpec;
+        adjustSourceParamDetailsForDestVariadic(reverseMatching ? destParamDetails : srcParamDetails, reverseMatching ? srcParamDetails : destParamDetails);
+        const targetIncludesParamSpec = reverseMatching ? !!srcType.details.paramSpec : !!destType.details.paramSpec;
         const destPositionalCount = (_b = (_a = destParamDetails.argsIndex) !== null && _a !== void 0 ? _a : destParamDetails.firstKeywordOnlyIndex) !== null && _b !== void 0 ? _b : destParamDetails.params.length;
         const srcPositionalCount = (_d = (_c = srcParamDetails.argsIndex) !== null && _c !== void 0 ? _c : srcParamDetails.firstKeywordOnlyIndex) !== null && _d !== void 0 ? _d : srcParamDetails.params.length;
         const positionalsToMatch = Math.min(destPositionalCount, srcPositionalCount);
@@ -17387,7 +17320,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 canAssign = false;
             }
         }
-        const effectiveSrcTypeVarContext = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? srcTypeVarContext : destTypeVarContext;
+        const effectiveSrcTypeVarContext = reverseMatching ? destTypeVarContext : srcTypeVarContext;
         // If the target function was generic and we solved some of the type variables
         // in that generic type, assign them back to the destination typeVar.
         const typeVarSignatureContext = effectiveSrcTypeVarContext.getPrimarySignature();
@@ -17397,8 +17330,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         // Are we assigning to a function with a ParamSpec?
         if (targetIncludesParamSpec) {
-            const effectiveDestType = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? destType : srcType;
-            const effectiveSrcType = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? srcType : destType;
+            const effectiveDestType = reverseMatching ? srcType : destType;
+            const effectiveSrcType = reverseMatching ? destType : srcType;
             if (effectiveDestType.details.paramSpec) {
                 const requiredMatchParamCount = effectiveDestType.details.parameters.filter((p) => {
                     if (!p.name) {
@@ -17451,9 +17384,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     remainingParams.forEach((param) => {
                         types_1.FunctionType.addParameter(remainingFunction, param);
                     });
-                    remainingFunction.details.paramSpec = srcParamSpec
-                        ? (0, typeUtils_1.convertToInstance)(srcParamSpec)
-                        : undefined;
+                    remainingFunction.details.paramSpec = srcParamSpec ? (0, typeUtils_1.convertToInstance)(srcParamSpec) : undefined;
                     if (!assignType(destParamSpec, remainingFunction, 
                     /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
                         // If we couldn't assign the function to the ParamSpec, see if we can
@@ -17703,7 +17634,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 matchIndex = possibleMatchIndex;
             }
             if (matchIndex < 0) {
-                continue;
+                break;
             }
             if (matchIndex < previousMatchIndex) {
                 diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadOrder());
@@ -17712,9 +17643,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             previousMatchIndex = matchIndex;
         }
         if (previousMatchIndex < baseOverloads.length - 1) {
-            // We didn't find matches for all of the base overloads.
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch());
-            return false;
+            const unmatchedOverloads = baseOverloads.slice(previousMatchIndex + 1);
+            // See if all of the remaining overrides are nonapplicable.
+            if (!baseClass ||
+                unmatchedOverloads.some((overload) => {
+                    return isOverrideMethodApplicable(overload, baseClass);
+                })) {
+                // We didn't find matches for all of the base overloads.
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch());
+                return false;
+            }
         }
         return true;
     }
@@ -18150,85 +18088,45 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return methodList;
     }
-    function bindFunctionToClassOrObjectWithErrors(baseType, memberType, memberClass, errorNode, treatConstructorAsClassMember = false, firstParamType) {
-        const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
-        const result = bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember, firstParamType, diag);
-        if (!result && errorNode && diag) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, diag.getString(), errorNode);
-        }
-        return result;
-    }
     // If the memberType is an instance or class method, creates a new
     // version of the function that has the "self" or "cls" parameter bound
-    // to it. If treatAsClassMethod is true, the function is treated like a
-    // class method even if it's not marked as such. That's needed to
-    // special-case the __new__ magic method when it's invoked as a
-    // constructor (as opposed to by name).
-    function bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember = false, firstParamType, diag, recursionCount = 0) {
-        if ((0, types_1.isFunction)(memberType)) {
+    // to it. If treatConstructorAsClassMember is true, the function is
+    // treated like a class method even if it's not marked as such. That's
+    // needed to special-case the __new__ magic method when it's invoked as
+    // a constructor (as opposed to by name).
+    function bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember = false, selfType, diag, recursionCount = 0) {
+        return (0, typeUtils_1.mapSignatures)(memberType, (functionType) => {
             // If the caller specified no base type, always strip the
             // first parameter. This is used in cases like constructors.
             if (!baseType) {
-                return types_1.FunctionType.clone(memberType, /* stripFirstParam */ true);
+                return types_1.FunctionType.clone(functionType, /* stripFirstParam */ true);
             }
-            if (types_1.FunctionType.isInstanceMethod(memberType)) {
+            if (types_1.FunctionType.isInstanceMethod(functionType)) {
                 // If the baseType is a metaclass, don't specialize the function.
                 if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
-                    return memberType;
+                    return functionType;
                 }
                 const baseObj = (0, types_1.isClassInstance)(baseType)
                     ? baseType
                     : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType));
-                return partiallySpecializeFunctionForBoundClassOrObject(baseType, memberType, memberClass || types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, firstParamType || baseObj, 
+                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));
             }
-            if (types_1.FunctionType.isClassMethod(memberType) ||
-                (treatConstructorAsClassMember && types_1.FunctionType.isConstructorMethod(memberType))) {
+            if (types_1.FunctionType.isClassMethod(functionType) ||
+                (treatConstructorAsClassMember && types_1.FunctionType.isConstructorMethod(functionType))) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
-                // If the caller passed an object as the base type, we need to also
-                // convert the firstParamType to an instantiable.
-                const effectiveFirstParamType = firstParamType
-                    ? (0, types_1.isInstantiableClass)(baseType)
-                        ? firstParamType
-                        : (0, typeUtils_1.convertToInstantiable)(firstParamType)
-                    : baseClass;
-                return partiallySpecializeFunctionForBoundClassOrObject(types_1.TypeBase.isInstance(baseType) ? types_1.ClassType.cloneAsInstantiable(baseType) : baseType, memberType, memberClass || baseClass, diag, recursionCount, effectiveFirstParamType, 
+                const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
+                return partiallySpecializeFunctionForBoundClassOrObject(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, clsType !== null && clsType !== void 0 ? clsType : baseClass, 
                 /* stripFirstParam */ true);
             }
-            if (types_1.FunctionType.isStaticMethod(memberType)) {
+            if (types_1.FunctionType.isStaticMethod(functionType)) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
-                return partiallySpecializeFunctionForBoundClassOrObject(types_1.TypeBase.isInstance(baseType) ? types_1.ClassType.cloneAsInstantiable(baseType) : baseType, memberType, memberClass || baseClass, diag, recursionCount, 
-                /* effectiveFirstParamType */ undefined, 
+                return partiallySpecializeFunctionForBoundClassOrObject(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, 
+                /* firstParamType */ undefined, 
                 /* stripFirstParam */ false);
             }
-        }
-        else if ((0, types_1.isOverloadedFunction)(memberType)) {
-            const newOverloadType = types_1.OverloadedFunctionType.create([]);
-            // Don't bother binding the implementation.
-            types_1.OverloadedFunctionType.getOverloads(memberType).forEach((overload) => {
-                const boundMethod = bindFunctionToClassOrObject(baseType, overload, memberClass, treatConstructorAsClassMember, firstParamType, 
-                /* diag */ undefined, recursionCount);
-                if (boundMethod) {
-                    types_1.OverloadedFunctionType.addOverload(newOverloadType, boundMethod);
-                }
-            });
-            const newOverloads = types_1.OverloadedFunctionType.getOverloads(newOverloadType);
-            if (newOverloads.length === 0) {
-                // No overloads matched, so rebind with the diag
-                // to report the error(s) to the user.
-                if (diag) {
-                    memberType.overloads.forEach((overload) => {
-                        bindFunctionToClassOrObject(baseType, overload, memberClass, treatConstructorAsClassMember, firstParamType, diag, recursionCount);
-                    });
-                }
-                return undefined;
-            }
-            if (newOverloads.length === 1) {
-                return newOverloads[0];
-            }
-            return newOverloadType;
-        }
-        return memberType;
+            return functionType;
+        });
     }
     // Specializes the specified function for the specified class,
     // optionally stripping the first first parameter (the "self" or "cls")
@@ -18333,6 +18231,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return true;
     }
+    function isLegalImplicitTypeAliasType(type) {
+        // We explicitly exclude "Unknown" and "...".
+        if ((0, types_1.isUnknown)(type) || (0, typeUtils_1.isEllipsisType)(type)) {
+            return false;
+        }
+        // Look at the subtypes within the union. If any of them are not
+        // instantiable (other than "None" which is special-cased), it is
+        // not a legal type alias type.
+        let isLegal = true;
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if (!types_1.TypeBase.isInstantiable(subtype) && !(0, typeUtils_1.isNoneInstance)(subtype)) {
+                isLegal = false;
+            }
+        });
+        return isLegal;
+    }
     function printObjectTypeForClass(type) {
         return TypePrinter.printObjectTypeForClass(type, evaluatorOptions.printTypeFlags, getFunctionEffectiveReturnType);
     }
@@ -18501,10 +18415,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getBestOverloadForArguments,
         getBuiltInType,
         getTypeOfMember,
-        getTypeOfObjectMember,
-        getTypeOfClassMemberName,
-        getBoundMethod,
-        getTypeOfMagicMethodReturn,
+        getTypeOfBoundMember,
+        getBoundMagicMethod,
+        getTypeOfMagicMethodCall,
         bindFunctionToClassOrObject,
         getCallSignatureInfo,
         getAbstractMethods,
@@ -18518,6 +18431,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypedDictClassType,
         getTupleClassType,
         getObjectType,
+        getNoneType,
         getBuiltInObject,
         getTypingType,
         assignTypeArguments,