@zzzen/pyright-internal 1.2.0-dev.20230903 → 1.2.0-dev.20230917

package/dist/analyzer/typeEvaluator.js

@@ -294,8 +294,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
     }
-    function setTypeForNode(node, type = types_1.UnknownType.create(), flags = 0 /* None */) {
-        writeTypeCache(node, { type }, flags);
+    function setTypeResultForNode(node, typeResult, flags = 0 /* None */) {
+        writeTypeCache(node, typeResult, flags);
     }
     function setAsymmetricDescriptorAssignment(node) {
         if (isSpeculativeModeInUse(/* node */ undefined)) {
@@ -399,6 +399,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             evaluateTypesForExpressionInContext(node);
         });
     }
+    function getTypeResultForDecorator(node) {
+        return evaluateTypeForSubnode(node, () => {
+            evaluateTypesForExpressionInContext(node.expression);
+        });
+    }
     // Reads the type of the node from the cache.
     function getCachedType(node) {
         return readTypeCache(node, 0 /* None */);
@@ -728,7 +733,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
                 types_1.ClassType.isTupleClass(typeResult.type) &&
                 ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
-            if (!isEmptyVariadic) {
+            const isEllipsis = (0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ellipsis');
+            if (!isEmptyVariadic && !isEllipsis) {
                 addExpectedClassDiagnostic(typeResult.type, node);
                 typeResult.type = types_1.UnknownType.create();
                 typeResult.typeErrors = true;
@@ -1243,8 +1249,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // 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) {
-        const memberInfo = getTypeOfClassMemberName(errorNode, types_1.ClassType.cloneAsInstantiable(objectType), 
-        /* isAccessedThroughObject */ true, memberName, usage, diag, memberAccessFlags | 8 /* DisallowClassVarWrites */, 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 */, types_1.ClassType.cloneAsInstantiable(objectType));
+            }
+        }
         if (memberInfo) {
             return {
                 type: memberInfo.type,
@@ -1261,7 +1278,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let memberInfo;
         const classDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
         const metaclassDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
-        let considerMetaclassOnly = (memberAccessFlags & 32 /* ConsiderMetaclassOnly */) !== 0;
+        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);
             return { type: types_1.UnknownType.create() };
@@ -1489,7 +1506,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const classTypeInfo = getTypeOfClass(enclosingClass);
                             if (classTypeInfo) {
                                 const classMemberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, expression.value, 8 /* SkipInstanceVariables */ |
-                                    16 /* DeclaredTypesOnly */);
+                                    32 /* DeclaredTypesOnly */);
                                 if (classMemberInfo) {
                                     symbol = classMemberInfo.symbol;
                                 }
@@ -1506,7 +1523,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, 16 /* DeclaredTypesOnly */);
+                    classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.memberName.value, 32 /* 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
@@ -1517,7 +1534,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 */ | 16 /* DeclaredTypesOnly */);
+                    classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseType, expression.memberName.value, 8 /* SkipInstanceVariables */ | 32 /* DeclaredTypesOnly */);
                     classOrObjectBase = baseType;
                     memberAccessClass = classMemberInfo === null || classMemberInfo === void 0 ? void 0 : classMemberInfo.classType;
                 }
@@ -2212,7 +2229,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, 16 /* DeclaredTypesOnly */);
+            memberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, memberName, 32 /* DeclaredTypesOnly */);
             if (!memberInfo && srcExprNode && !isTypeIncomplete) {
                 reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownMemberType, diagnosticRules_1.DiagnosticRule.reportUnknownMemberType, node.memberName, srcType, node, 
                 /* ignoreEmptyContainers */ true);
@@ -2351,8 +2368,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If this is a TypeVarTuple *Ts, convert it to an unpacked tuple
             // *tuple[*Ts].
             if ((0, types_1.isVariadicTypeVar)(subtype)) {
+                // If it's in a union, convert to type or object.
                 if (subtype.isVariadicInUnion) {
-                    return subtype;
+                    if (types_1.TypeBase.isInstantiable(subtype)) {
+                        if (typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
+                            return typeClassType;
+                        }
+                    }
+                    else if (objectType) {
+                        return objectType;
+                    }
+                    return types_1.AnyType.create();
                 }
                 if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                     return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: subtype, isUnbounded: false }], 
@@ -3230,9 +3256,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 nestedClassCount++;
             }
             else if (curNode.nodeType === 28 /* Function */) {
-                const functionTypeInfo = getTypeOfFunction(curNode);
-                if (functionTypeInfo) {
-                    const functionDetails = functionTypeInfo.functionType.details;
+                const functionType = getTypeOfFunctionPredecorated(curNode);
+                if (functionType) {
+                    const functionDetails = functionType.details;
                     typeParametersForScope = functionDetails.typeParameters;
                     // Was this type parameter "rescoped" to a callable found within the
                     // return type annotation? If so, it is not available for use within
@@ -3696,20 +3722,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (flags & 1 /* AccessClassMembersOnly */) {
             classLookupFlags |= 8 /* SkipInstanceVariables */;
         }
-        if (flags & 2 /* SkipBaseClasses */) {
+        if (flags & 2 /* AccessInstanceMembersOnly */) {
+            classLookupFlags |= 16 /* SkipClassVariables */;
+        }
+        if (flags & 4 /* SkipBaseClasses */) {
             classLookupFlags |= 2 /* SkipBaseClasses */;
         }
-        if (flags & 4 /* SkipObjectBaseClass */) {
+        if (flags & 8 /* SkipObjectBaseClass */) {
             classLookupFlags |= 4 /* SkipObjectBaseClass */;
         }
-        if (flags & 256 /* SkipTypeBaseClass */) {
-            classLookupFlags |= 32 /* SkipTypeBaseClass */;
+        if (flags & 512 /* SkipTypeBaseClass */) {
+            classLookupFlags |= 64 /* SkipTypeBaseClass */;
         }
-        if (flags & 128 /* SkipOriginalClass */) {
+        if (flags & 256 /* SkipOriginalClass */) {
             classLookupFlags |= 1 /* SkipOriginalClass */;
         }
         // Always look for a member with a declared type first.
-        let memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, classLookupFlags | 16 /* DeclaredTypesOnly */);
+        let memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, classLookupFlags | 32 /* DeclaredTypesOnly */);
         // If we couldn't find a symbol with a declared type, use
         // a symbol with an inferred type.
         if (!memberInfo) {
@@ -3746,7 +3775,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (typeResult) {
                                 if ((0, typeUtils_1.isDescriptorInstance)(typeResult.type, /* requireSetter */ true)) {
                                     type = typeResult.type;
-                                    flags &= 8 /* DisallowClassVarWrites */;
+                                    flags &= 16 /* DisallowClassVarWrites */;
                                 }
                             }
                         }
@@ -3848,7 +3877,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // No attribute of that name was found. If this is a member access
         // through an object, see if there's an attribute access override
         // method ("__getattr__", etc.).
-        if ((flags & (1 /* AccessClassMembersOnly */ | 64 /* SkipAttributeAccessOverride */)) ===
+        if ((flags & (1 /* AccessClassMembersOnly */ | 128 /* SkipAttributeAccessOverride */)) ===
             0) {
             const generalAttrType = applyAttributeAccessOverride(classType, errorNode, usage, memberName);
             if (generalAttrType) {
@@ -3869,7 +3898,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // 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 & 16 /* TreatConstructorAsClassMethod */) !== 0;
+        const treatConstructorAsClassMember = (flags & 32 /* TreatConstructorAsClassMethod */) !== 0;
         let isTypeValid = true;
         let isAsymmetricAccessor = false;
         type = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
@@ -4111,7 +4140,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (usage.method === 'set') {
                 if (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.isClassVar()) {
-                    if (flags & 8 /* DisallowClassVarWrites */) {
+                    if (flags & 16 /* DisallowClassVarWrites */) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberSetClassVar().format({ name: memberName }));
                         isTypeValid = false;
                         return undefined;
@@ -4248,7 +4277,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // 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, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
+            /* diag */ undefined, 8 /* SkipObjectBaseClass */ | 128 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
         };
         let accessMemberType;
         if (usage.method === 'get') {
@@ -4663,7 +4692,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (flags & 128 /* ExpectingInstantiableType */) === 0) {
                     const itemMethodType = getTypeOfClassMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
                     /* usage */ undefined, 
-                    /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */);
+                    /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 64 /* ConsiderMetaclassOnly */);
                     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({
@@ -4899,10 +4928,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const itemMethodType = (0, types_1.isClassInstance)(baseType)
             ? (_a = getTypeOfObjectMember(node, baseType, magicMethodName, 
             /* usage */ undefined, 
-            /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type
+            /* diag */ undefined, 128 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type
             : (_b = getTypeOfClassMember(node, baseType, magicMethodName, 
             /* usage */ undefined, 
-            /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */)) === null || _b === void 0 ? void 0 : _b.type;
+            /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 64 /* ConsiderMetaclassOnly */)) === null || _b === void 0 ? void 0 : _b.type;
         if (!itemMethodType) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
@@ -5160,7 +5189,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeArgs.push(getTypeArgTypeResult(item, index));
             });
             // Set the node's type so it isn't reevaluated later.
-            setTypeForNode(node.items[0].valueExpression, types_1.UnknownType.create());
+            setTypeResultForNode(node.items[0].valueExpression, { type: types_1.UnknownType.create() });
         }
         else {
             node.items.forEach((arg, index) => {
@@ -5204,7 +5233,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 node,
             };
             // Set the node's type so it isn't reevaluated later.
-            setTypeForNode(node, types_1.UnknownType.create());
+            setTypeResultForNode(node, { type: types_1.UnknownType.create() });
         }
         else if (node.nodeType === 15 /* Dictionary */ && supportsDictExpression) {
             const inlinedTypeDict = typedDictClassType && (0, types_1.isInstantiableClass)(typedDictClassType)
@@ -5269,7 +5298,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         matchingSubtype = subtype;
                     }
                 }
-            });
+            }, 
+            /* sortSubtypes */ true);
             effectiveExpectedType = matchingSubtype;
         }
         let expectedTypeDiagAddendum;
@@ -6106,7 +6136,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!isDiagnosticSuppressedForNode(errorNode)) {
                 const functionName = typeResult.type.overloads[0].details.name || '<anonymous function>';
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                const argTypes = argList.map((t) => printType(getTypeOfArgument(t).type));
+                const argTypes = argList.map((t) => {
+                    const typeString = printType(getTypeOfArgument(t).type);
+                    if (t.argumentCategory === 1 /* UnpackedList */) {
+                        return `*${typeString}`;
+                    }
+                    if (t.argumentCategory === 2 /* UnpackedDictionary */) {
+                        return `**${typeString}`;
+                    }
+                    return typeString;
+                });
                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
             }
@@ -6610,7 +6649,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a, _b;
         const memberType = (_a = getTypeOfObjectMember(errorNode, expandedCallType, '__call__', 
         /* usage */ undefined, 
-        /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === null || _a === void 0 ? void 0 : _a.type;
+        /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === 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),
@@ -6866,14 +6905,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // all positional parameters specified in the Concatenate must be
                 // filled explicitly.
                 if (typeResult.type.details.paramSpec && paramIndex < positionParamLimitIndex) {
-                    if (!isDiagnosticSuppressedForNode(errorNode)) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                            ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                            : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                                expected: positionParamLimitIndex,
-                            }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                    if ((0, types_1.isTypeVar)(argTypeResult.type) && argTypeResult.type.paramSpecAccess === 'args') {
+                        if (!isDiagnosticSuppressedForNode(errorNode)) {
+                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                                ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
+                                : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                    expected: positionParamLimitIndex,
+                                }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                        }
+                        reportedArgError = true;
                     }
-                    reportedArgError = true;
                 }
                 const argType = argTypeResult.type;
                 if (isParamVariadic && (0, types_1.isUnpackedVariadicTypeVar)(argType)) {
@@ -7159,17 +7200,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             reportedArgError = true;
                         }
                     }
-                    else if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'kwargs') {
+                    else if (typeResult.type.details.paramSpec &&
+                        (0, parameterUtils_1.isParamSpecKwargsArgument)(typeResult.type.details.paramSpec, argType)) {
                         unpackedDictionaryArgType = types_1.AnyType.create();
-                        if (typeResult.type.details.paramSpec) {
-                            validateArgTypeParams.push({
-                                paramCategory: 2 /* KwargsDict */,
-                                paramType: typeResult.type.details.paramSpec,
-                                requiresTypeVarMatching: false,
-                                argument: argList[argIndex],
-                                errorNode: argList[argIndex].valueExpression || errorNode,
-                            });
-                        }
+                        validateArgTypeParams.push({
+                            paramCategory: 2 /* KwargsDict */,
+                            paramType: typeResult.type.details.paramSpec,
+                            requiresTypeVarMatching: false,
+                            argument: argList[argIndex],
+                            argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
+                            errorNode: argList[argIndex].valueExpression || errorNode,
+                        });
                     }
                     else {
                         const strObjType = getBuiltInObject(errorNode, 'str');
@@ -7297,20 +7338,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
-                        // Handle the case where a *args: P.args is passed as an argument to
-                        // a function that accepts a ParamSpec.
+                        // Handle the case where a *args: P.args (or *args: Any) is passed as an
+                        // argument to a function that accepts a ParamSpec.
                         if (typeResult.type.details.paramSpec) {
                             const argTypeResult = getTypeOfArgument(argList[argIndex]);
                             const argType = argTypeResult.type;
                             if (argTypeResult.isIncomplete) {
                                 isTypeIncomplete = true;
                             }
-                            if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'args') {
+                            if ((0, parameterUtils_1.isParamSpecArgsArgument)(typeResult.type.details.paramSpec, argType)) {
                                 validateArgTypeParams.push({
                                     paramCategory: 1 /* ArgsList */,
                                     paramType: typeResult.type.details.paramSpec,
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
+                                    argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
                                     errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
                                 });
                             }
@@ -7563,7 +7605,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return subtype;
                         }
                         return undefined;
-                    });
+                    }, 
+                    /* sortSubtypes */ true);
                     if ((0, types_1.isClassInstance)(filteredType)) {
                         effectiveExpectedType = filteredType;
                     }
@@ -7729,12 +7772,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (type.details.paramSpec) {
                 if (argParam.argument.argumentCategory === 1 /* UnpackedList */) {
-                    if ((0, types_1.isParamSpec)(argResult.argType) && argResult.argType.paramSpecAccess === 'args') {
+                    if ((0, parameterUtils_1.isParamSpecArgsArgument)(type.details.paramSpec, argResult.argType)) {
                         sawParamSpecArgs = true;
                     }
                 }
                 if (argParam.argument.argumentCategory === 2 /* UnpackedDictionary */) {
-                    if ((0, types_1.isParamSpec)(argResult.argType) && argResult.argType.paramSpecAccess === 'kwargs') {
+                    if ((0, parameterUtils_1.isParamSpecKwargsArgument)(type.details.paramSpec, argResult.argType)) {
                         sawParamSpecKwargs = true;
                     }
                 }
@@ -8676,6 +8719,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 functionType.details.paramSpec = typeResult.type;
                 return functionType;
             }
+            if ((0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ellipsis')) {
+                types_1.FunctionType.addDefaultParameters(functionType);
+                return functionType;
+            }
         }
         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecDefaultNotTuple(), node);
         return undefined;
@@ -8933,12 +8980,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClassInstance)(concreteSubtype)) {
                 magicMethodType = (_a = getTypeOfObjectMember(errorNode, concreteSubtype, magicMethodName, 
                 /* usage */ undefined, 
-                /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === null || _a === void 0 ? void 0 : _a.type;
+                /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === null || _a === void 0 ? void 0 : _a.type;
             }
             else if ((0, types_1.isInstantiableClass)(concreteSubtype)) {
                 magicMethodType = (_b = getTypeOfClassMember(errorNode, concreteSubtype, magicMethodName, 
                 /* usage */ undefined, 
-                /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */)) === null || _b === void 0 ? void 0 : _b.type;
+                /* diag */ undefined, 128 /* SkipAttributeAccessOverride */ | 64 /* ConsiderMetaclassOnly */)) === null || _b === void 0 ? void 0 : _b.type;
             }
             if (magicMethodType) {
                 const functionArgs = args.map((arg) => {
@@ -9027,7 +9074,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         matchingSubtypeResult = subtypeResult;
                     }
                 }
-            });
+            }, 
+            /* sortSubtypes */ true);
             effectiveExpectedType = matchingSubtype;
         }
         let expectedTypeDiagAddendum = undefined;
@@ -9344,7 +9392,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         matchingSubtypeResult = subtypeResult;
                     }
                 }
-            });
+            }, 
+            /* sortSubtypes */ true);
             effectiveExpectedType = matchingSubtype;
         }
         let expectedTypeDiagAddendum;
@@ -10644,6 +10693,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return (0, typeUtils_1.convertToInstance)(typeVar);
         });
+        const typeAliasScopeId = ParseTreeUtils.getScopeIdForNode(name);
         // Validate the default types for all type parameters.
         typeParameters.forEach((typeParam, index) => {
             var _a;
@@ -10651,7 +10701,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (typeParamNodes && index < typeParamNodes.length) {
                 bestErrorNode = (_a = typeParamNodes[index].defaultExpression) !== null && _a !== void 0 ? _a : typeParamNodes[index].name;
             }
-            validateTypeParameterDefault(bestErrorNode, typeParam, typeParameters.slice(0, index));
+            validateTypeParameterDefault(bestErrorNode, typeParam, typeParameters.slice(0, index), typeAliasScopeId);
         });
         // Verify that we have at most one variadic type variable.
         const variadics = typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
@@ -10661,7 +10711,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), errorNode);
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
-        const typeAliasScopeId = ParseTreeUtils.getScopeIdForNode(name);
         const boundTypeVars = typeParameters.filter((typeVar) => typeVar.scopeId !== typeAliasScopeId && typeVar.scopeType === 0 /* Class */);
         if (boundTypeVars.length > 0) {
             addError(localize_1.Localizer.Diagnostic.genericTypeAliasBoundTypeVar().format({
@@ -11203,14 +11252,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (types_1.ClassType.isBuiltIn(argType, 'TypedDict') || types_1.ClassType.isTypedDictClass(argType)) {
                                 classType.details.flags |= 128 /* TypedDictClass */;
                             }
-                            else if (types_1.ClassType.isTypedDictClass(classType) && !types_1.ClassType.isTypedDictClass(argType)) {
-                                // Exempt Generic from this test. As of Python 3.11, generic TypedDict
-                                // classes are supported.
-                                if (!(0, types_1.isInstantiableClass)(argType) || !types_1.ClassType.isBuiltIn(argType, 'Generic')) {
-                                    // TypedDict classes must derive only from other TypedDict classes.
-                                    addError(localize_1.Localizer.Diagnostic.typedDictBaseClass(), arg);
-                                }
-                            }
                             // Validate that the class isn't deriving from itself, creating a
                             // circular dependency.
                             if ((0, typeUtils_1.derivesFromClassRecursive)(argType, classType, /* ignoreUnknown */ true)) {
@@ -11371,7 +11412,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const typeParamNode = node.typeParameters.parameters[index];
                     bestErrorNode = (_a = typeParamNode.defaultExpression) !== null && _a !== void 0 ? _a : typeParamNode.name;
                 }
-                validateTypeParameterDefault(bestErrorNode, typeParam, classType.details.typeParameters.slice(0, index));
+                validateTypeParameterDefault(bestErrorNode, typeParam, classType.details.typeParameters.slice(0, index), classType.details.typeVarScopeId);
             });
             if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
                 addError(localize_1.Localizer.Diagnostic.methodOrdering(), node.name);
@@ -11507,6 +11548,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             registerDeferredClassCompletion(node, /* dependsUpon */ undefined);
             // Synthesize TypedDict methods.
             if (types_1.ClassType.isTypedDictClass(classType)) {
+                // TypedDict classes must derive only from other TypedDict classes.
+                let foundInvalidBaseClass = false;
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                classType.details.baseClasses.forEach((baseClass) => {
+                    if ((0, types_1.isClass)(baseClass) &&
+                        !types_1.ClassType.isTypedDictClass(baseClass) &&
+                        !types_1.ClassType.isBuiltIn(baseClass, ['_TypedDict', 'Generic'])) {
+                        foundInvalidBaseClass = true;
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictBaseClass().format({ type: baseClass.details.name }));
+                    }
+                });
+                if (foundInvalidBaseClass) {
+                    addError(localize_1.Localizer.Diagnostic.typedDictBaseClass() + diag.getString(), node.name);
+                }
                 (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, (0, types_1.isClass)(decoratedType) && types_1.ClassType.isFinal(decoratedType));
             }
             // Synthesize dataclass methods.
@@ -11523,7 +11578,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 let skipSynthesizeHash = false;
                 const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 2 /* SkipBaseClasses */);
-                if (hashSymbol) {
+                // If there is a hash symbol defined in the class (i.e. one that we didn't
+                // synthesize above), then we shouldn't synthesize a new one for the dataclass.
+                if (hashSymbol && !hashSymbol.symbol.getSynthesizedType()) {
                     skipSynthesizeHash = true;
                 }
                 (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
@@ -11573,11 +11630,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // type parameter. If so, validates that it is in the list of "live" type
     // parameters and updates the scope of the type parameter referred to in the
     // default type expression.
-    function validateTypeParameterDefault(errorNode, typeParam, otherLiveTypeParams) {
+    function validateTypeParameterDefault(errorNode, typeParam, otherLiveTypeParams, scopeId) {
         if (!typeParam.details.defaultType &&
             !typeParam.details.isSynthesized &&
             !typeParam.details.isSynthesizedSelf) {
-            const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType);
+            const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType && param.scopeId === scopeId);
             if (typeVarWithDefault) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarWithoutDefault().format({
                     name: typeParam.details.name,
@@ -11812,8 +11869,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const initSubclassMethodInfo = getTypeOfClassMemberName(errorNode, classType, 
         /* isAccessedThroughObject */ false, '__init_subclass__', { method: 'get' }, 
         /* diag */ undefined, 1 /* AccessClassMembersOnly */ |
-            4 /* SkipObjectBaseClass */ |
-            128 /* SkipOriginalClass */, classType);
+            8 /* SkipObjectBaseClass */ |
+            256 /* SkipOriginalClass */, classType);
         if (initSubclassMethodInfo) {
             const initSubclassMethodType = initSubclassMethodInfo.type;
             if (initSubclassMethodType) {
@@ -11824,7 +11881,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         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__', 32 /* SkipTypeBaseClass */);
+            const newMethodMember = (0, typeUtils_1.lookUpClassMember)(classType.details.effectiveMetaclass, '__new__', 64 /* SkipTypeBaseClass */);
             if (newMethodMember) {
                 const newMethodType = getTypeOfMember(newMethodMember);
                 if ((0, types_1.isFunction)(newMethodType)) {
@@ -11887,20 +11944,72 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
     }
     function getTypeOfFunction(node) {
-        var _a, _b;
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        // Is this type already cached?
-        const cachedFunctionType = readTypeCache(node.name, 0 /* None */);
-        if (cachedFunctionType) {
-            if (!(0, types_1.isFunction)(cachedFunctionType)) {
+        // Is this predecorated function type cached?
+        let functionType = readTypeCache(node.name, 0 /* None */);
+        if (functionType) {
+            if (!(0, types_1.isFunction)(functionType)) {
                 // This can happen in certain rare circumstances where the
                 // function declaration falls within an unreachable code block.
                 return undefined;
             }
-            return {
-                functionType: cachedFunctionType,
-                decoratedType: readTypeCache(node, 0 /* None */) || types_1.UnknownType.create(),
-            };
+        }
+        else {
+            functionType = getTypeOfFunctionPredecorated(node);
+        }
+        // Is the decorated function type cached?
+        let decoratedType = readTypeCache(node, 0 /* None */);
+        if (decoratedType) {
+            return { functionType, decoratedType };
+        }
+        // Populate the cache with a temporary value to handle recursion.
+        writeTypeCache(node, { type: functionType }, /* flags */ undefined);
+        // If it's an async function, wrap the return type in an Awaitable or Generator.
+        // Set the "partially evaluated" flag around this logic to detect recursion.
+        functionType.details.flags |= 131072 /* PartiallyEvaluated */;
+        const preDecoratedType = node.isAsync ? createAsyncFunction(node, functionType) : functionType;
+        functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
+        // Apply all of the decorators in reverse order.
+        decoratedType = preDecoratedType;
+        let foundUnknown = false;
+        for (let i = node.decorators.length - 1; i >= 0; i--) {
+            const decorator = node.decorators[i];
+            const newDecoratedType = (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node);
+            const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
+            if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
+                // Report this error only on the first unknown type.
+                if (!foundUnknown) {
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedFunctionDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedFunctionDecorator, localize_1.Localizer.Diagnostic.functionDecoratorTypeUnknown(), node.decorators[i].expression);
+                    foundUnknown = true;
+                }
+            }
+            else {
+                // Apply the decorator only if the type is known.
+                decoratedType = newDecoratedType;
+            }
+        }
+        // See if there are any overloads provided by previous function declarations.
+        if ((0, types_1.isFunction)(decoratedType)) {
+            if (types_1.FunctionType.isOverloaded(decoratedType)) {
+                // Mark all the parameters as accessed.
+                node.parameters.forEach((param) => {
+                    markParamAccessed(param);
+                });
+            }
+            decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
+        }
+        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
+        return { functionType, decoratedType };
+    }
+    // Evaluates the type of a "def" statement without applying an async
+    // modifier or any decorators.
+    function getTypeOfFunctionPredecorated(node) {
+        var _a, _b, _c;
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        // Is this type already cached?
+        const cachedFunctionType = readTypeCache(node.name, 0 /* None */);
+        if (cachedFunctionType && (0, types_1.isFunction)(cachedFunctionType)) {
+            return cachedFunctionType;
         }
         let functionDecl;
         const decl = AnalyzerNodeInfo.getDeclaration(node);
@@ -11912,11 +12021,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
         let containingClassType;
         if (containingClassNode) {
-            const classInfo = getTypeOfClass(containingClassNode);
-            if (!classInfo) {
-                return undefined;
-            }
-            containingClassType = classInfo.classType;
+            containingClassType = (_a = getTypeOfClass(containingClassNode)) === null || _a === void 0 ? void 0 : _a.classType;
         }
         let functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, node, !!containingClassNode);
         if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.isGenerator) {
@@ -11945,14 +12050,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             functionType.details.builtInName = node.name.value;
         }
         functionType.details.declaration = functionDecl;
-        // Allow recursion by registering the partially-constructed
-        // function type.
+        // Allow recursion by caching and registering the partially-constructed function type.
         const scope = ScopeUtils.getScopeForNode(node);
         const functionSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(node.name.value);
         if (functionDecl && functionSymbol) {
             setSymbolResolutionPartialType(functionSymbol.symbol, functionDecl, functionType);
         }
-        writeTypeCache(node, { type: functionType }, /* flags */ undefined);
         writeTypeCache(node.name, { type: functionType }, /* flags */ undefined);
         // Is this an "__init__" method within a pseudo-generic class? If so,
         // we'll add generic types to the constructor's parameters.
@@ -11992,14 +12095,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             functionType.details.typeParameters = typeParametersSeen;
         }
-        const markParamAccessed = (param) => {
-            if (param.name) {
-                const symbolWithScope = lookUpSymbolRecursive(param.name, param.name.value, /* honorCodeFlow */ false);
-                if (symbolWithScope) {
-                    setSymbolAccessed(fileInfo, symbolWithScope.symbol, param.name);
-                }
-            }
-        };
         let paramsArePositionOnly = true;
         const isFirstParamClsOrSelf = containingClassType &&
             (types_1.FunctionType.isClassMethod(functionType) ||
@@ -12181,7 +12276,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If there was a defined return type, analyze that first so when we
         // walk the contents of the function, return statements can be
         // validated against this type.
-        const returnTypeAnnotationNode = (_a = node.returnTypeAnnotation) !== null && _a !== void 0 ? _a : (_b = node.functionAnnotationComment) === null || _b === void 0 ? void 0 : _b.returnTypeAnnotation;
+        const returnTypeAnnotationNode = (_b = node.returnTypeAnnotation) !== null && _b !== void 0 ? _b : (_c = node.functionAnnotationComment) === null || _c === void 0 ? void 0 : _c.returnTypeAnnotation;
         if (returnTypeAnnotationNode) {
             // Temporarily set the return type to unknown in case of recursion.
             functionType.details.declaredReturnType = types_1.UnknownType.create();
@@ -12232,45 +12327,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeParamNode = node.typeParameters.parameters[index];
                 bestErrorNode = (_a = typeParamNode.defaultExpression) !== null && _a !== void 0 ? _a : typeParamNode.name;
             }
-            validateTypeParameterDefault(bestErrorNode, typeParam, functionType.details.typeParameters.slice(0, index));
+            validateTypeParameterDefault(bestErrorNode, typeParam, functionType.details.typeParameters.slice(0, index), functionType.details.typeVarScopeId);
         });
-        // If it's an async function, wrap the return type in an Awaitable or Generator.
-        const preDecoratedType = node.isAsync ? createAsyncFunction(node, functionType) : functionType;
         // Clear the "partially evaluated" flag to indicate that the functionType
         // is fully evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
-        // Apply all of the decorators in reverse order.
-        let decoratedType = preDecoratedType;
-        let foundUnknown = false;
-        for (let i = node.decorators.length - 1; i >= 0; i--) {
-            const decorator = node.decorators[i];
-            const newDecoratedType = (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node);
-            const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
-            if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
-                // Report this error only on the first unknown type.
-                if (!foundUnknown) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedFunctionDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedFunctionDecorator, localize_1.Localizer.Diagnostic.functionDecoratorTypeUnknown(), node.decorators[i].expression);
-                    foundUnknown = true;
-                }
-            }
-            else {
-                // Apply the decorator only if the type is known.
-                decoratedType = newDecoratedType;
-            }
-        }
-        // See if there are any overloads provided by previous function declarations.
-        if ((0, types_1.isFunction)(decoratedType)) {
-            if (types_1.FunctionType.isOverloaded(decoratedType)) {
-                // Mark all the parameters as accessed.
-                node.parameters.forEach((param) => {
-                    markParamAccessed(param);
-                });
+        writeTypeCache(node.name, { type: functionType }, 0 /* None */);
+        return functionType;
+    }
+    function markParamAccessed(param) {
+        if (param.name) {
+            const symbolWithScope = lookUpSymbolRecursive(param.name, param.name.value, /* honorCodeFlow */ false);
+            if (symbolWithScope) {
+                setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(param), symbolWithScope.symbol, param.name);
             }
-            decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
         }
-        writeTypeCache(node.name, { type: functionType }, 0 /* None */);
-        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
-        return { functionType, decoratedType };
     }
     // If the declared return type of a function contains type variables that
     // are found nowhere else in the signature and are contained within a
@@ -14228,7 +14299,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, 16 /* DeclaredTypesOnly */);
+                        let member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName, 32 /* DeclaredTypesOnly */);
                         if (!member) {
                             member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
                         }
@@ -14245,7 +14316,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, 16 /* DeclaredTypesOnly */);
+                        let member = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName, 32 /* DeclaredTypesOnly */);
                         if (!member) {
                             member = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
                         }
@@ -14311,7 +14382,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else if ((0, types_1.isInstantiableClass)(baseType)) {
                         const initMethodType = (_b = getTypeOfObjectMember(argNode.parent.leftExpression, types_1.ClassType.cloneAsInstance(baseType), '__init__', { method: 'get' }, 
-                        /* diag */ undefined, 4 /* SkipObjectBaseClass */)) === null || _b === void 0 ? void 0 : _b.type;
+                        /* diag */ undefined, 8 /* SkipObjectBaseClass */)) === null || _b === void 0 ? void 0 : _b.type;
                         if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
                             const paramDecl = getDeclarationFromFunctionNamedParameter(initMethodType, paramName);
                             if (paramDecl) {
@@ -14625,25 +14696,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (resolvedDecl.type === 8 /* Alias */) {
             // Build a module type that corresponds to the declaration and
             // its associated loader actions.
-            let moduleName = resolvedDecl.moduleName;
-            if (decl.type === 8 /* Alias */) {
-                if (decl.symbolName) {
-                    moduleName += '.' + decl.symbolName;
-                }
-                // If the module name is relative to the current file, use that
-                // file's module name as a reference.
-                if (moduleName.startsWith('.')) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(decl.node);
-                    const nameParts = fileInfo.moduleName.split('.');
-                    moduleName = moduleName.substr(1);
-                    while (moduleName.startsWith('.') && nameParts.length > 0) {
-                        moduleName = moduleName.substr(1);
-                        nameParts.pop();
-                    }
-                    moduleName = nameParts.join('.') + '.' + moduleName;
-                }
-            }
-            const moduleType = types_1.ModuleType.create(moduleName, resolvedDecl.path);
+            const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.path);
             if (resolvedDecl.symbolName && resolvedDecl.submoduleFallback) {
                 return applyLoaderActionsToModuleType(moduleType, resolvedDecl.submoduleFallback, importLookup);
             }
@@ -15778,7 +15831,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (destType.typeArguments) {
             // If the dest type is specialized, make sure the specialized source
             // type arguments are assignable to the dest type arguments.
-            return assignTypeArguments(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+            return assignTypeArguments(destType, curSrcType, 
+            // Don't emit a diag addendum if we're in an invariant context. It's
+            // sufficient to simply indicate that the types are not the same
+            // in this case. Adding more information is unnecessary and confusing.
+            (flags & 1 /* EnforceInvariance */) === 0 ? diag : undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
         }
         if (destTypeVarContext && curSrcType.typeArguments && !destTypeVarContext.isLocked()) {
             // Populate the typeVar map with type arguments of the source.
@@ -16187,9 +16244,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isInstantiableClass)(destType)) {
             if ((0, types_1.isInstantiableClass)(expandedSrcType)) {
-                // PEP 544 says that if the dest type is a Type[Proto] class,
+                // PEP 544 says that if the dest type is a type[Proto] class,
                 // the source must be a "concrete" (non-protocol) class.
-                if (types_1.ClassType.isProtocolClass(destType)) {
+                if (types_1.ClassType.isProtocolClass(destType) &&
+                    (flags & 4096 /* IgnoreProtocolAssignmentCheck */) === 0) {
                     if (types_1.ClassType.isProtocolClass(expandedSrcType) &&
                         (0, types_1.isInstantiableClass)(srcType) &&
                         !srcType.includeSubclasses) {
@@ -17313,6 +17371,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     !srcParamSpec ||
                     !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, { ignoreTypeFlags: true })) {
                     const remainingFunction = types_1.FunctionType.createInstance('', '', '', effectiveSrcType.details.flags | 64 /* SynthesizedMethod */, effectiveSrcType.details.docString);
+                    remainingFunction.details.deprecatedMessage = effectiveSrcType.details.deprecatedMessage;
                     remainingFunction.details.typeVarScopeId = effectiveSrcType.details.typeVarScopeId;
                     remainingFunction.details.constructorTypeVarScopeId =
                         effectiveSrcType.details.constructorTypeVarScopeId;
@@ -18319,6 +18378,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         runWithCancellationToken,
         getType,
         getTypeResult,
+        getTypeResultForDecorator,
         getCachedType,
         getTypeOfExpression,
         getTypeOfAnnotation,
@@ -18408,7 +18468,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         disposeEvaluator,
         useSpeculativeMode,
         isSpeculativeModeInUse,
-        setTypeForNode,
+        setTypeResultForNode,
         checkForCancellation,
         printControlFlowGraph,
         printTypeVarContext,