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

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 getTypeOfObjectMember(errorNode, objectType, memberName, usage = { method: 'get' }, diag = undefined, flags = 0 /* Default */, selfType) {
+        if (types_1.ClassType.isPartiallyEvaluated(objectType)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classDefinitionCycle().format({ name: objectType.details.name }), errorNode);
             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));
+            // 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 getBoundMethod(classType, memberName, recursionCount = 0) {
+        const memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, 16 /* SkipInstanceMembers */);
+        if (!memberInfo) {
+            return undefined;
+        }
+        const unboundMethodType = getTypeOfMember(memberInfo);
+        if ((0, types_1.isFunction)(unboundMethodType) || (0, types_1.isOverloadedFunction)(unboundMethodType)) {
+            return bindFunctionToClassOrObject(types_1.ClassType.cloneAsInstance(classType), unboundMethodType, 
+            /* memberClass */ undefined, 
+            /* treatConstructorAsClassMember */ true, 
+            /* selfType */ undefined, 
+            /* diag */ undefined, recursionCount);
+        }
+        if ((0, types_1.isAnyOrUnknown)(unboundMethodType)) {
+            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,12 +1465,12 @@ 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;
                         // Try to get the `__init__` method first because it typically has more
@@ -1460,9 +1485,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // 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);
+                            const constructorType = getBoundMethod(subtype, '__new__');
                             if (constructorType) {
                                 // Is this the __new__ method provided by the object class?
                                 const isObjectNew = (0, types_1.isFunction)(constructorType) &&
@@ -1494,6 +1517,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 +1595,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 +1612,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 +1623,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;
                 }
@@ -1668,17 +1732,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 +1751,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 +1784,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 +1819,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 +1828,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 +1874,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 +1897,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;
@@ -1935,9 +1986,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, 
         /* reference */ undefined, 
         /* targetSymbolId */ undefined, 
-        /* typeAtStart */ types_1.UnboundType.create(), {
-            skipNoReturnCallAnalysis: true,
-        });
+        /* typeAtStart */ types_1.UnboundType.create());
         return codeFlowResult.type !== undefined && !(0, types_1.isNever)(codeFlowResult.type);
     }
     // Determines whether there is a code flow path from sourceNode to sinkNode.
@@ -2194,7 +2243,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
@@ -2212,7 +2261,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);
@@ -2259,7 +2308,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);
@@ -2390,6 +2439,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 &&
@@ -2445,22 +2495,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) {
@@ -2496,32 +2530,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;
@@ -2533,7 +2555,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) {
@@ -2561,10 +2583,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);
             });
         }
@@ -2576,7 +2599,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;
@@ -2606,7 +2629,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 const filteredTypeArg = mapSubtypesExpandTypeVars(typeArg, conditionFilter, (expandedSubtype) => {
                     return expandedSubtype;
-                }, recursionCount);
+                }, 
+                /* sortSubtypes */ undefined, recursionCount);
                 if (filteredTypeArg !== typeArg) {
                     typeWasTransformed = true;
                 }
@@ -2837,41 +2861,7 @@ 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) {
-        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol;
@@ -3019,29 +3009,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type = types_1.UnknownType.create();
             }
         }
-        if ((0, types_1.isTypeVar)(type) &&
-            !type.details.isParamSpec &&
-            !type.isVariadicInUnion &&
-            (flags & 128 /* ExpectingInstantiableType */) === 0 &&
-            type.details.name === name) {
-            // Handle the special case of a PEP 604 union. These can appear within
-            // an implied type alias where we are not expecting a type.
-            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* BinaryOperation */ &&
-                node.parent.operator === 6 /* BitwiseOr */;
-            if (!isPep604Union) {
-                // A TypeVar in contexts where we're not expecting a type is
-                // simply a TypeVar or TypeVarTuple object.
-                const typeVarType = type.details.isVariadic
-                    ? getTypingType(node, 'TypeVarTuple')
-                    : getTypingType(node, 'TypeVar');
-                if (typeVarType && (0, types_1.isInstantiableClass)(typeVarType)) {
-                    type = types_1.ClassType.cloneAsInstance(typeVarType);
-                }
-                else {
-                    type = types_1.UnknownType.create();
-                }
-            }
-        }
+        type = convertTypeVarToRuntimeInstance(node, type, flags);
         if ((flags & 256 /* ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
@@ -3062,6 +3030,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
+    // If the type is a TypeVar and we're not expecting a type, convert
+    // a TypeVar or TypeVarTuple into a runtime type. We don't currently
+    // do this for ParamSpec (although we arguably should) because it's
+    // problematic for handling P.args and P.kwargs.
+    function convertTypeVarToRuntimeInstance(node, type, flags) {
+        var _a;
+        if (node.nodeType === 38 /* Name */ &&
+            (0, types_1.isTypeVar)(type) &&
+            node.value === type.details.name &&
+            !type.isVariadicInUnion &&
+            (flags & 128 /* ExpectingInstantiableType */) === 0) {
+            if ((flags & 33554432 /* SkipConvertParamSpecToRuntimeObject */) !== 0 && type.details.isParamSpec) {
+                return type;
+            }
+            // Handle the special case of a PEP 604 union. These can appear within
+            // an implied type alias where we are not expecting a type.
+            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* BinaryOperation */ &&
+                node.parent.operator === 6 /* BitwiseOr */;
+            if (!isPep604Union) {
+                // A TypeVar in contexts where we're not expecting a type is
+                // simply a runtime object.
+                if (type.details.runtimeClass) {
+                    type = types_1.ClassType.cloneAsInstance(type.details.runtimeClass);
+                }
+                else {
+                    type = types_1.UnknownType.create();
+                }
+            }
+        }
+        return type;
+    }
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (either a function or a lambda).
     function getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType) {
@@ -3387,15 +3386,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, isRescoped: false, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
-        const baseTypeFlags = 16777218 /* MemberAccessBaseDefaults */ |
-            (flags &
+        var _a;
+        // Compute flags specifically for evaluating the left expression.
+        let leftExprFlags = 16777218 /* MemberAccessBaseDefaults */;
+        leftExprFlags |=
+            flags &
                 (256 /* ExpectingTypeAnnotation */ |
                     32768 /* VariableTypeAnnotation */ |
                     4 /* AllowForwardReferences */ |
                     524288 /* NotParsedByInterpreter */ |
                     2048 /* DisallowTypeVarsWithScopeId */ |
-                    8192 /* AssociateTypeVarsWithCurrentScope */));
-        const baseTypeResult = getTypeOfExpression(node.leftExpression, baseTypeFlags);
+                    8192 /* AssociateTypeVarsWithCurrentScope */);
+        // Handle special casing for ParamSpec "args" and "kwargs" accesses.
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0) {
+            const memberName = node.memberName.value;
+            if (memberName === 'args' || memberName === 'kwargs') {
+                leftExprFlags |= 33554432 /* SkipConvertParamSpecToRuntimeObject */;
+            }
+        }
+        const baseTypeResult = getTypeOfExpression(node.leftExpression, leftExprFlags);
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             return {
                 type: types_1.UnknownType.create(/* isIncomplete */ true),
@@ -3443,12 +3452,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();
@@ -3471,113 +3496,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 : getTypeOfObjectMember(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, 
@@ -3593,12 +3595,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);
@@ -3641,10 +3643,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 = getTypeOfObjectMember(node.memberName, noneType, memberName, usage, diag);
                         if (typeResult) {
                             type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
                             if (typeResult.isIncomplete) {
@@ -3652,42 +3659,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];
@@ -3697,29 +3690,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) ||
@@ -3741,7 +3720,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
@@ -3751,159 +3730,133 @@ 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) {
+        var _a, _b, _c, _d;
+        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 (!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) {
+                const generalAttrType = applyAttributeAccessOverride(classType, errorNode, usage, memberName, selfType);
+                if (generalAttrType) {
+                    return {
+                        symbol: undefined,
+                        type: generalAttrType.type,
+                        isTypeIncomplete: false,
+                        isDescriptorError: false,
+                        isClassMember: false,
+                        isClassVar: false,
+                        isAsymmetricAccessor: generalAttrType.isAsymmetricAccessor,
+                    };
+                }
             }
-            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 */;
-                                }
+            // 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;
+        }
+        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 = (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 (!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;
+                    if (!type) {
+                        type = types_1.UnknownType.create();
                     }
                 }
-                else if (memberName === '__new__') {
-                    selfClass = undefined;
-                }
-                const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
-                if (typeResult) {
-                    type = typeResult.type;
-                    if (typeResult.isIncomplete) {
-                        isTypeIncomplete = true;
-                    }
+            }
+        }
+        if (!type) {
+            let selfClass = classType;
+            // Determine whether to replace Self variables with a specific
+            // class. Avoid doing this if there's a "selfType" specified
+            // because that case is used for super() calls where we want
+            // to leave the Self type generic (not specialized). We'll also
+            // skip this for __new__ methods because they are not bound
+            // to the class but rather assume the type of the cls argument.
+            if (selfType) {
+                if ((0, types_1.isTypeVar)(selfType) && selfType.details.isSynthesizedSelf) {
+                    selfClass = selfType;
                 }
                 else {
-                    type = types_1.UnknownType.create();
+                    selfClass = undefined;
                 }
             }
-            // 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;
-                }
+            else if (memberName === '__new__') {
+                selfClass = 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 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;
             }
-            const descriptorResult = applyDescriptorAccessMethod(type, memberInfo, classType, bindToType, isAccessedThroughObject, flags, errorNode, memberName, usage, diag);
-            if (!descriptorResult) {
+        }
+        // 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;
             }
-            type = descriptorResult.type;
-            let isSetTypeError = false;
+        }
+        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 descResult = applyDescriptorAccessMethod(type, memberInfo, classType, selfType, flags, errorNode, memberName, usage, diag);
+        let isDescriptorError = true;
+        if (descResult) {
+            isDescriptorError = false;
+            type = descResult.type;
             if (usage.method === 'set' && usage.setType) {
                 // Verify that the assigned type is compatible.
                 if (!assignType(type, usage.setType.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
@@ -3914,7 +3867,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             classType: printObjectTypeForClass(classType),
                         }));
                     }
-                    isSetTypeError = true;
+                    isDescriptorError = true;
                 }
                 if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
                     types_1.ClassType.isFrozenDataClass(memberInfo.classType) &&
@@ -3922,47 +3875,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     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;
+                    isDescriptorError = true;
                 }
             }
-            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,
-            };
-        }
-        // 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,
-                };
-            }
         }
-        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
-        return undefined;
+        return {
+            symbol: memberInfo.symbol,
+            type,
+            isTypeIncomplete,
+            isDescriptorError,
+            isClassMember: !memberInfo.isInstanceMember,
+            isClassVar: memberInfo.isClassVar,
+            classType: memberInfo.classType,
+            isAsymmetricAccessor: (_d = descResult === null || descResult === void 0 ? void 0 : descResult.isAsymmetricAccessor) !== null && _d !== void 0 ? _d : false,
+            memberAccessDeprecationInfo: descResult === null || descResult === void 0 ? void 0 : descResult.memberAccessDeprecationInfo,
+        };
     }
     // 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;
+    function applyDescriptorAccessMethod(type, memberInfo, classType, selfType, flags, errorNode, memberName, usage, diag) {
+        const treatConstructorAsClassMember = (flags & 256 /* TreatConstructorAsClassMethod */) !== 0;
+        const isAccessedThroughObject = types_1.TypeBase.isInstance(classType);
         let isTypeValid = true;
         let isAsymmetricAccessor = false;
         let memberAccessDeprecationInfo;
@@ -4004,7 +3938,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else {
                         accessMethodName = '__delete__';
                     }
-                    const accessMethod = (0, typeUtils_1.lookUpClassMember)(lookupClass, accessMethodName, 8 /* SkipInstanceVariables */);
+                    const accessMethod = (0, typeUtils_1.lookUpClassMember)(lookupClass, accessMethodName, 16 /* SkipInstanceMembers */);
                     // Handle properties specially.
                     if (types_1.ClassType.isPropertyClass(lookupClass)) {
                         if (usage.method === 'set') {
@@ -4034,10 +3968,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 argumentCategory: 0 /* Simple */,
                                 typeResult: {
                                     type: types_1.ClassType.isClassProperty(lookupClass)
-                                        ? baseTypeClass
+                                        ? classType
                                         : isAccessedThroughObject
-                                            ? bindToType !== null && bindToType !== void 0 ? bindToType : types_1.ClassType.cloneAsInstance(baseTypeClass)
-                                            : types_1.NoneType.createInstance(),
+                                            ? selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType)
+                                            : getNoneType(),
                                 },
                             },
                         ];
@@ -4046,7 +3980,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
                                 typeResult: {
-                                    type: baseTypeClass,
+                                    type: isAccessedThroughObject
+                                        ? types_1.ClassType.cloneAsInstantiable(classType)
+                                        : classType,
                                 },
                             });
                         }
@@ -4075,8 +4011,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // 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)) {
+                            if ((flags & 16 /* SkipInstanceMembers */) !== 0 &&
+                                types_1.ClassType.isProtocolClass(classType)) {
                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyAccessFromProtocolClass());
                                 isTypeValid = false;
                             }
@@ -4095,12 +4031,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 // 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;
+                                        bindToClass = types_1.ClassType.cloneAsInstance(memberInfo.classType);
                                     }
                                 }
                                 let boundMethodType = bindFunctionToClassOrObjectWithErrors(lookupClass, methodType, bindToClass, errorNode, 
@@ -4112,7 +4043,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     ((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);
+                                        const specializedBoundType = (0, typeUtils_1.partiallySpecializeType)(boundMethodType, bindToClass, classType);
                                         if (specializedBoundType) {
                                             if ((0, types_1.isFunction)(specializedBoundType) ||
                                                 (0, types_1.isOverloadedFunction)(specializedBoundType)) {
@@ -4151,6 +4082,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.noOverload().format({ name: accessMethodName }));
                                             }
                                         }
+                                        else {
+                                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.descriptorAccessCallFailed().format({
+                                                name: accessMethodName,
+                                                className: printType((0, typeUtils_1.convertToInstance)(accessMethod.classType)),
+                                            }));
+                                        }
                                         isTypeValid = false;
                                         return types_1.AnyType.create();
                                     }
@@ -4159,6 +4096,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         ? (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create()
                                         : types_1.AnyType.create();
                                 }
+                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.descriptorAccessBindingFailed().format({
+                                    name: accessMethodName,
+                                    className: printType((0, typeUtils_1.convertToInstance)(accessMethod.classType)),
+                                }));
+                                isTypeValid = false;
                                 return undefined;
                             });
                             // Determine if we're calling __set__ on an asymmetric descriptor or property.
@@ -4199,29 +4141,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // 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);
+                    return bindFunctionToClassOrObjectWithErrors(classType, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, treatConstructorAsClassMember, selfType && (0, types_1.isClass)(selfType) ? types_1.ClassType.cloneIncludeSubclasses(selfType) : selfType);
                 }
             }
             if (usage.method === 'set') {
                 if (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.isClassVar()) {
-                    if (flags & 16 /* DisallowClassVarWrites */) {
+                    if (flags & 128 /* DisallowClassVarWrites */) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberSetClassVar().format({ name: memberName }));
                         isTypeValid = false;
                         return undefined;
@@ -4351,14 +4276,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return isAsymmetric;
     }
     // Applies the __getattr__, __setattr__ or __delattr__ method if present.
-    function applyAttributeAccessOverride(classType, errorNode, usage, memberName) {
+    function applyAttributeAccessOverride(classType, errorNode, 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 = getTypeOfObjectMember(errorNode, classType, name, { method: 'get' }, 
+            /* diag */ undefined, 16 /* SkipInstanceMembers */ |
+                4 /* SkipObjectBaseClass */ |
+                512 /* SkipAttributeAccessOverride */, selfType)) === null || _a === void 0 ? void 0 : _a.type;
         };
         let accessMemberType;
         if (usage.method === 'get') {
@@ -4371,51 +4296,47 @@ 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;
+        }
+        let nameLiteralType = types_1.AnyType.create();
+        if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
+            nameLiteralType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName);
+        }
+        const argList = [
+            {
+                // Provide "name" argument.
+                argumentCategory: 0 /* Simple */,
+                typeResult: { type: nameLiteralType },
+            },
+        ];
+        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 (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,
-                    };
-                }
-            }
+            });
         }
-        return undefined;
+        if (!(0, types_1.isFunction)(accessMemberType) && !(0, types_1.isOverloadedFunction)(accessMemberType)) {
+            // TODO - need to handle and report this error.
+            return undefined;
+        }
+        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(accessMemberType));
+        const callResult = validateCallArguments(errorNode, argList, { type: accessMemberType }, typeVarContext, 
+        /* skipUnknownArgCheck */ true);
+        // TODO - need to handle and report errors when validating call to
+        // attribute access method.
+        let isAsymmetricAccessor = false;
+        if (usage.method === 'set') {
+            isAsymmetricAccessor = isClassWithAsymmetricAttributeAccessor(classType);
+        }
+        return {
+            type: (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create(),
+            isAsymmetricAccessor,
+        };
     }
     function getTypeOfIndex(node, flags = 0 /* None */) {
         const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* IndexBaseDefaults */);
@@ -4771,9 +4692,9 @@ 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), 
+                    const itemMethodType = getTypeOfObjectMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
                     /* usage */ undefined, 
-                    /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 64 /* ConsiderMetaclassOnly */);
+                    /* diag */ undefined, 512 /* SkipAttributeAccessOverride */);
                     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({
@@ -4861,6 +4782,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) {
@@ -4871,10 +4798,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);
@@ -4937,7 +4860,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 */);
@@ -4948,7 +4871,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.
@@ -4997,7 +4920,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfIndexedObjectOrClass(node, baseType, usage) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         // 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);
@@ -5006,13 +4929,9 @@ 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 = (_a = getTypeOfObjectMember(node, baseType, magicMethodName, 
+        /* usage */ undefined, 
+        /* diag */ undefined, 512 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
         if (!itemMethodType) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
@@ -5141,7 +5060,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 = (_c = (_b = usage.setType) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 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;
@@ -5152,7 +5071,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argumentCategory: 0 /* Simple */,
                 typeResult: {
                     type: setType,
-                    isIncomplete: !!((_e = usage.setType) === null || _e === void 0 ? void 0 : _e.isIncomplete),
+                    isIncomplete: !!((_d = usage.setType) === null || _d === void 0 ? void 0 : _d.isIncomplete),
                 },
             });
         }
@@ -5202,7 +5121,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: (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
@@ -5531,7 +5450,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */ | (flags & 4 /* AllowForwardReferences */));
         }
-        const argList = node.arguments.map((arg) => {
+        const argList = ParseTreeUtils.getArgumentsByRuntimeOrder(node).map((arg) => {
             const functionArg = {
                 valueExpression: arg.valueExpression,
                 argumentCategory: arg.argumentCategory,
@@ -5792,7 +5711,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;
@@ -5817,6 +5736,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);
@@ -5912,8 +5841,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,
                 };
             }
@@ -6403,7 +6332,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.
@@ -6420,7 +6350,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
@@ -6435,37 +6365,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 };
             }
@@ -6596,7 +6519,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)) {
@@ -6744,7 +6667,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a, _b;
         const memberType = (_a = getTypeOfObjectMember(errorNode, expandedCallType, '__call__', 
         /* usage */ undefined, 
-        /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === null || _a === void 0 ? void 0 : _a.type;
+        /* diag */ undefined, 512 /* SkipAttributeAccessOverride */ | 16 /* SkipInstanceMembers */)) === null || _a === void 0 ? void 0 : _a.type;
         if (!memberType) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
                 type: printType(expandedCallType),
@@ -7006,8 +6929,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()
@@ -8125,6 +8050,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);
@@ -8147,8 +8073,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] };
@@ -8312,7 +8267,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)) {
@@ -8455,7 +8410,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false);
+        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false, classType);
         // Parse the remaining parameters.
         const paramNameMap = new Map();
         for (let i = 1; i < argList.length; i++) {
@@ -8581,7 +8536,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false);
+        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false, classType);
         typeVar.details.isVariadic = true;
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
@@ -8633,7 +8588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.paramSpecFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const paramSpec = types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true);
+        const paramSpec = types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true, classType);
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
             const paramNameNode = argList[i].name;
@@ -8876,7 +8831,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 */);
@@ -8923,10 +8878,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 */ ||
@@ -8943,30 +8895,22 @@ 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;
+            var _a;
             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, 
+            if ((0, types_1.isClass)(concreteSubtype)) {
+                magicMethodType = (_a = getTypeOfObjectMember(errorNode, concreteSubtype, methodName, 
                 /* usage */ undefined, 
-                /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 64 /* ConsiderMetaclassOnly */)) === null || _b === void 0 ? void 0 : _b.type;
+                /* diag */ undefined, 16 /* SkipInstanceMembers */ | 512 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
             }
             if (magicMethodType) {
-                const functionArgs = args.map((arg) => {
+                const functionArgs = argList.map((arg) => {
                     return {
                         argumentCategory: 0 /* Simple */,
                         typeResult: arg,
@@ -9002,13 +8946,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));
@@ -9618,12 +9562,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type: returnedType };
     }
     function getTypeOfLambda(node, inferenceContext) {
-        let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
-        const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
-        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
-        // Pre-cache the incomplete function type in case the evaluation of the
-        // lambda depends on itself.
-        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
         let expectedFunctionTypes = [];
         if (inferenceContext) {
             (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (subtype) => {
@@ -9638,30 +9576,54 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return undefined;
             });
-            // Determine the minimum number of parameters that are required to
-            // satisfy the lambda.
-            const minLambdaParamCount = node.parameters.filter((param) => param.category === 0 /* Simple */ && !!param.name && param.defaultValue === undefined).length;
-            const maxLambdaParamCount = node.parameters.filter((param) => param.category === 0 /* Simple */ && !!param.name).length;
-            // Remove any expected subtypes that don't satisfy the minimum
-            // parameter count requirement.
-            expectedFunctionTypes = expectedFunctionTypes.filter((functionType) => {
-                const functionParamCount = functionType.details.parameters.filter((param) => !!param.name && !param.hasDefault).length;
-                const hasVarArgs = functionType.details.parameters.some((param) => !!param.name && param.category !== 0 /* Simple */);
-                const hasParamSpec = !!functionType.details.paramSpec;
-                return (hasVarArgs ||
-                    hasParamSpec ||
-                    (functionParamCount >= minLambdaParamCount && functionParamCount <= maxLambdaParamCount));
-            });
         }
-        // For now, use only the first expected type.
-        const expectedFunctionType = expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined;
+        if (expectedFunctionTypes.length <= 1) {
+            return getTypeOfLambdaWithExpectedType(node, expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined, inferenceContext, 
+            /* forceSpeculative */ false);
+        }
+        // Sort the expected types for deterministic results.
+        expectedFunctionTypes = (0, typeUtils_1.sortTypes)(expectedFunctionTypes);
+        // If there's more than one type, try each in turn until we find one that works.
+        for (const expectedFunctionType of expectedFunctionTypes) {
+            const result = getTypeOfLambdaWithExpectedType(node, expectedFunctionType, inferenceContext, 
+            /* forceSpeculative */ true);
+            if (!result.typeErrors) {
+                return getTypeOfLambdaWithExpectedType(node, expectedFunctionType, inferenceContext, 
+                /* forceSpeculative */ false);
+            }
+        }
+        return getTypeOfLambdaWithExpectedType(node, expectedFunctionTypes[0], inferenceContext, 
+        /* forceSpeculative */ true);
+    }
+    function getTypeOfLambdaWithExpectedType(node, expectedType, inferenceContext, forceSpeculative) {
+        let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
         let paramsArePositionOnly = true;
-        const expectedParamDetails = expectedFunctionType ? (0, parameterUtils_1.getParameterListDetails)(expectedFunctionType) : undefined;
+        const expectedParamDetails = expectedType ? (0, parameterUtils_1.getParameterListDetails)(expectedType) : undefined;
+        const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
+        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        // Pre-cache the incomplete function type in case the evaluation of the
+        // lambda depends on itself.
+        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
+        // 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
@@ -9721,9 +9683,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        const expectedReturnType = expectedFunctionType
-            ? getFunctionEffectiveReturnType(expectedFunctionType)
-            : undefined;
+        const expectedReturnType = expectedType ? getFunctionEffectiveReturnType(expectedType) : undefined;
+        let typeErrors = false;
         // If we're speculatively evaluating the lambda, create another speculative
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
@@ -9731,19 +9692,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cache the type of the lambda return expression because it depends on
         // the parameter types that we set above, and the speculative type cache
         // doesn't know about that context.
-        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
+        useSpeculativeMode(forceSpeculative || isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)
+            ? node.expression
+            : undefined, () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
             /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (returnTypeResult.typeErrors) {
+                typeErrors = true;
+            }
         }, {
-            dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
+            dependentType: expectedType,
         });
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
-        return { type: functionType, isIncomplete };
+        // Is the resulting function compatible with the expected type?
+        if (expectedType && !assignType(expectedType, functionType)) {
+            typeErrors = true;
+        }
+        return { type: functionType, isIncomplete, typeErrors };
     }
     function getTypeOfListComprehension(node, inferenceContext) {
         var _a;
@@ -9763,8 +9733,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) {
@@ -9784,9 +9754,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 };
@@ -10115,7 +10083,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);
         }
@@ -10178,7 +10146,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 */ &&
@@ -10202,7 +10170,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;
                             }
                         }
@@ -10613,7 +10581,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);
             }
         }
@@ -10962,8 +10930,7 @@ 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);
@@ -11089,6 +11056,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) {
@@ -11109,7 +11077,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 */;
@@ -11328,8 +11297,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         metaclassNode = arg.valueExpression;
                     }
                 }
-                else if (types_1.ClassType.isTypedDictClass(classType) &&
-                    (arg.name.value === 'total' || arg.name.value === 'readonly')) {
+                else if (types_1.ClassType.isTypedDictClass(classType) && arg.name.value === 'total') {
                     // The "total" and "readonly" parameters apply only for TypedDict classes.
                     // PEP 589 specifies that the parameter must be either True or False.
                     const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
@@ -11339,9 +11307,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if (arg.name.value === 'total' && !constArgValue) {
                         classType.details.flags |= 256 /* CanOmitDictValues */;
                     }
-                    else if (arg.name.value === 'readonly' && constArgValue) {
-                        classType.details.flags |= 512 /* DictValuesReadOnly */;
-                    }
                 }
                 else {
                     // Collect arguments that will be passed to the `__init_subclass__`
@@ -11421,7 +11386,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
@@ -11867,22 +11832,22 @@ 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);
+        const initSubclassMethodInfo = getTypeOfObjectMember(errorNode, classType, '__init_subclass__', { method: 'get' }, 
+        /* diag */ undefined, 32 /* SkipClassMembers */ |
+            4 /* SkipObjectBaseClass */ |
+            1 /* SkipOriginalClass */ |
+            512 /* SkipAttributeAccessOverride */);
         if (initSubclassMethodInfo) {
             const initSubclassMethodType = initSubclassMethodInfo.type;
             if (initSubclassMethodType) {
                 validateCallArguments(errorNode, argList, { type: initSubclassMethodType }, 
                 /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(types_1.NoneType.createInstance()));
+                /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()));
             }
         }
         else 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 */);
+            const newMethodMember = (0, typeUtils_1.lookUpClassMember)(classType.details.effectiveMetaclass, '__new__', 8 /* SkipTypeBaseClass */);
             if (newMethodMember) {
                 const newMethodType = getTypeOfMember(newMethodMember);
                 if ((0, types_1.isFunction)(newMethodType)) {
@@ -11945,6 +11910,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) {
@@ -12307,7 +12273,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();
@@ -12400,7 +12366,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;
     }
@@ -12460,7 +12426,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()]);
             }
@@ -12658,13 +12624,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
@@ -12706,14 +12672,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
@@ -12727,7 +12693,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());
                             }
@@ -12844,7 +12810,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__';
@@ -12855,7 +12821,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.
@@ -12865,7 +12831,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());
                     }
@@ -12885,7 +12851,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;
@@ -14234,6 +14200,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 .getDeclarations()
                                 .find((decl) => decl.type === 2 /* Parameter */);
                         }
+                        const parameterDetails = (0, parameterUtils_1.getParameterListDetails)(type);
+                        if (parameterDetails.unpackedKwargsTypedDictType) {
+                            const lookupResults = (0, typeUtils_1.lookUpClassMember)(parameterDetails.unpackedKwargsTypedDictType, paramName);
+                            if (lookupResults) {
+                                return lookupResults.symbol
+                                    .getDeclarations()
+                                    .find((decl) => decl.type === 1 /* Variable */);
+                            }
+                        }
                     }
                 }
             }
@@ -14314,7 +14289,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);
                         }
@@ -14331,7 +14306,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);
                         }
@@ -14397,7 +14372,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;
+                        /* diag */ undefined, 4 /* SkipObjectBaseClass */)) === null || _b === void 0 ? void 0 : _b.type;
                         if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
                             const paramDecl = getDeclarationFromFunctionNamedParameter(initMethodType, paramName);
                             if (paramDecl) {
@@ -14461,7 +14436,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 };
@@ -14574,13 +14549,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (cachedTypeVarType && (0, types_1.isTypeVar)(cachedTypeVarType)) {
             return cachedTypeVarType;
         }
-        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value);
-        typeVar.details.isTypeParamSyntax = true;
+        let runtimeClassName = 'TypeVar';
         if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
-            typeVar.details.isVariadic = true;
+            runtimeClassName = 'TypeVarTuple';
         }
         else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
-            typeVar.details.isParamSpec = true;
+            runtimeClassName = 'ParamSpec';
+        }
+        const runtimeType = getTypingType(node, runtimeClassName);
+        const runtimeClass = runtimeType && (0, types_1.isInstantiableClass)(runtimeType) ? runtimeType : undefined;
+        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value, node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec, runtimeClass);
+        typeVar.details.isTypeParamSyntax = true;
+        if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
+            typeVar.details.isVariadic = true;
         }
         // Cache the value before we evaluate the bound or the default type in
         // case it refers to itself in a circular manner.
@@ -14803,9 +14784,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;
@@ -14909,7 +14888,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
-        var _a, _b;
         let declaredTypeInfo;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
@@ -14942,13 +14920,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let cacheEntries = effectiveTypeCache.get(symbol.id);
         const usageNodeId = usageNode ? usageNode.id : undefined;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
-        if (cacheEntries) {
-            const result = cacheEntries.get(effectiveTypeCacheKey);
-            if (result) {
-                if (!result.isIncomplete) {
-                    return result;
-                }
-            }
+        const cacheEntry = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey);
+        if (cacheEntry && !cacheEntry.isIncomplete) {
+            return cacheEntry;
         }
         // Infer the type.
         const decls = symbol.getDeclarations();
@@ -15037,8 +15011,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             declsToConsider.push(resolvedDecl);
         });
-        const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
-        const result = getTypeOfSymbolForDecls(symbol, declsToConsider, evaluationAttempts);
+        const result = getTypeOfSymbolForDecls(symbol, declsToConsider, effectiveTypeCacheKey);
         // Add the result to the effective type cache if it doesn't include speculative results.
         if (!result.includesSpeculativeResult) {
             addToEffectiveTypeCache(result);
@@ -15054,7 +15027,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     // Returns the type of a symbol based on a subset of its declarations.
-    function getTypeOfSymbolForDecls(symbol, decls, evaluationAttempts) {
+    function getTypeOfSymbolForDecls(symbol, decls, typeCacheKey) {
+        var _a, _b;
         const typesToCombine = [];
         let isIncomplete = false;
         let sawPendingEvaluation = false;
@@ -15122,6 +15096,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 sawPendingEvaluation = true;
             }
         });
+        // How many times have we already attempted to evaluate this declaration already?
+        const cacheEntries = effectiveTypeCache.get(symbol.id);
+        const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(typeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
         let type;
         if (typesToCombine.length > 0) {
             // Ignore the pending evaluation flag if we've already attempted the
@@ -15276,7 +15253,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;
@@ -16239,23 +16216,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;
@@ -16307,6 +16284,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?
@@ -16525,13 +16515,13 @@ 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, 
+        if ((0, typeUtils_1.isNoneInstance)(srcType) && (0, types_1.isClassInstance)(destType) && types_1.ClassType.isProtocolClass(destType)) {
+            if (noneClassType && (0, types_1.isInstantiableClass)(noneClassType)) {
+                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), noneClassType, diag, destTypeVarContext, srcTypeVarContext, flags, 
                 /* treatSourceAsInstantiable */ false, recursionCount);
             }
         }
-        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;
         }
@@ -16788,7 +16778,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 {
@@ -17071,15 +17061,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);
@@ -17352,7 +17341,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();
@@ -17362,8 +17351,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) {
@@ -17416,9 +17405,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
@@ -17677,9 +17664,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;
     }
@@ -18115,9 +18109,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return methodList;
     }
-    function bindFunctionToClassOrObjectWithErrors(baseType, memberType, memberClass, errorNode, treatConstructorAsClassMember = false, firstParamType) {
+    function bindFunctionToClassOrObjectWithErrors(baseType, memberType, memberClass, errorNode, treatConstructorAsClassMember = false, selfType) {
         const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
-        const result = bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember, firstParamType, diag);
+        const result = bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember, selfType, diag);
         if (!result && errorNode && diag) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, diag.getString(), errorNode);
         }
@@ -18125,75 +18119,43 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // 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, 
+                const baseObj = (0, types_1.isInstantiableClass)(baseType)
+                    ? types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType))
+                    : baseType;
+                return partiallySpecializeFunctionForBoundClassOrObject(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, 
                 /* stripFirstParam */ (0, types_1.isClassInstance)(baseType));
             }
-            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")
@@ -18298,6 +18260,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);
     }
@@ -18467,9 +18445,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getBuiltInType,
         getTypeOfMember,
         getTypeOfObjectMember,
-        getTypeOfClassMemberName,
         getBoundMethod,
-        getTypeOfMagicMethodReturn,
+        getTypeOfMagicMethodCall,
         bindFunctionToClassOrObject,
         getCallSignatureInfo,
         getAbstractMethods,
@@ -18483,6 +18460,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypedDictClassType,
         getTupleClassType,
         getObjectType,
+        getNoneType,
         getBuiltInObject,
         getTypingType,
         assignTypeArguments,