@zzzen/pyright-internal 1.2.0-dev.20230813 → 1.2.0-dev.20230827

package/dist/analyzer/typeEvaluator.js

@@ -683,10 +683,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
+    // Reports the case where a function or class has been decorated with
+    // @type_check_only and is used in a value expression.
+    function reportUseOfTypeCheckOnly(type, node) {
+        let isTypeCheckingOnly = false;
+        let name = '';
+        if ((0, types_1.isInstantiableClass)(type) && !type.includeSubclasses) {
+            isTypeCheckingOnly = types_1.ClassType.isTypeCheckOnly(type);
+            name = type.details.name;
+        }
+        else if ((0, types_1.isFunction)(type)) {
+            isTypeCheckingOnly = types_1.FunctionType.isTypeCheckOnly(type);
+            name = type.details.name;
+        }
+        if (isTypeCheckingOnly) {
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            if (!fileInfo.isStubFile) {
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeCheckOnly().format({ name }), node);
+            }
+        }
+    }
     function reportInvalidUseOfPep695TypeAlias(type, node) {
         var _a;
         // PEP 695 type aliases cannot be used as instantiable classes.
-        if (((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.name) && type.typeAliasInfo.isPep695Syntax) {
+        if (((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.name) && type.typeAliasInfo.isPep695Syntax && types_1.TypeBase.isSpecialForm(type)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasNotAllowed().format({ name: type.typeAliasInfo.name }), node);
             return true;
         }
@@ -980,9 +1000,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (options === null || options === void 0 ? void 0 : options.associateTypeVarsWithScope) {
             evaluatorFlags |= 8192 /* AssociateTypeVarsWithCurrentScope */;
         }
-        else {
-            evaluatorFlags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
-        }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTypedDict) {
             evaluatorFlags |= 8388608 /* AllowUnpackedTypedDict */;
         }
@@ -1237,11 +1254,30 @@ 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;
         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() };
         }
-        if ((memberAccessFlags & 32 /* ConsiderMetaclassOnly */) === 0) {
+        const metaclass = classType.details.effectiveMetaclass;
+        // 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.
+        if (usage.method === 'get' &&
+            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, classType);
+            if (metaclassMemberInfo && (0, typeUtils_1.isDescriptorInstance)(metaclassMemberInfo.type)) {
+                considerMetaclassOnly = 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);
         }
@@ -2507,14 +2543,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (types_1.ClassType.isBuiltIn(callType, 'TypeVar') ||
                         types_1.ClassType.isBuiltIn(callType, 'TypeVarTuple') ||
                         types_1.ClassType.isBuiltIn(callType, 'ParamSpec'))) {
-                    if (target.nodeType !== 38 /* Name */ || target.value !== type.details.name) {
+                    const typeVarTarget = target.nodeType === 54 /* TypeAnnotation */ ? target.valueExpression : target;
+                    if (typeVarTarget.nodeType !== 38 /* Name */ || typeVarTarget.value !== type.details.name) {
                         addError(type.details.isParamSpec
                             ? localize_1.Localizer.Diagnostic.paramSpecAssignedName().format({
                                 name: types_1.TypeVarType.getReadableName(type),
                             })
                             : localize_1.Localizer.Diagnostic.typeVarAssignedName().format({
                                 name: types_1.TypeVarType.getReadableName(type),
-                            }), target);
+                            }), typeVarTarget);
                     }
                 }
             }
@@ -2922,6 +2959,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        if ((flags & 256 /* ExpectingTypeAnnotation */) === 0) {
+            reportUseOfTypeCheckOnly(type, node);
+        }
         if ((flags & 16777216 /* DisallowPep695TypeAlias */) !== 0) {
             if (reportInvalidUseOfPep695TypeAlias(type, node)) {
                 type = types_1.UnknownType.create();
@@ -3079,7 +3119,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
-            else if ((flags & 4096 /* DisallowTypeVarsWithoutScopeId */) !== 0) {
+            else if ((flags & 4096 /* AllowTypeVarsWithoutScopeId */) === 0) {
                 if ((type.scopeId === undefined || scopedTypeVarInfo.foundInterveningClass) &&
                     !type.details.isSynthesized) {
                     let message;
@@ -3271,7 +3311,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     4 /* AllowForwardReferences */ |
                     524288 /* NotParsedByInterpreter */ |
                     2048 /* DisallowTypeVarsWithScopeId */ |
-                    4096 /* DisallowTypeVarsWithoutScopeId */ |
                     8192 /* AssociateTypeVarsWithCurrentScope */));
         const baseTypeResult = getTypeOfExpression(node.leftExpression, baseTypeFlags);
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
@@ -3392,7 +3431,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                 }
-                if (flags & 256 /* ExpectingTypeAnnotation */) {
+                if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0) {
                     if (!isIncomplete) {
                         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNoMember().format({
                             type: printType(baseType),
@@ -3616,6 +3655,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // additional reportUnknownMemberType diagnostics.
             type = isFunctionRule ? types_1.AnyType.create() : types_1.UnknownType.create();
         }
+        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) {
@@ -3708,13 +3750,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (!type) {
+                let selfClass = classType;
                 // Determine whether to replace Self variables with a specific
                 // class. Avoid doing this if there's a "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.
-                const selfClass = !!bindToType || memberName === '__new__' ? undefined : classType;
+                if (bindToType) {
+                    if ((0, types_1.isTypeVar)(bindToType) && bindToType.details.isSynthesizedSelf) {
+                        selfClass = bindToType;
+                    }
+                    else {
+                        selfClass = undefined;
+                    }
+                }
+                else if (memberName === '__new__') {
+                    selfClass = undefined;
+                }
                 const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
                 if (typeResult) {
                     type = typeResult.type;
@@ -3888,10 +3941,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             },
                         ];
                         if (usage.method === 'get') {
-                            // Provide "objtype" argument.
+                            // Provide "owner" argument.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                typeResult: { type: baseTypeClass },
+                                typeResult: {
+                                    type: baseTypeClass,
+                                },
                             });
                         }
                         else if (usage.method === 'set') {
@@ -4248,14 +4303,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfIndex(node, flags = 0 /* None */) {
         const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* IndexBaseDefaults */);
         // If this is meant to be a type and the base expression is a string expression,
-        // emit an error because this will generate a runtime exception in Python versions
-        // less than 3.10.
+        // emit an error because this is an illegal annotation form and will generate a
+        // runtime exception.
         if (flags & 128 /* ExpectingInstantiableType */) {
             if (node.baseExpression.nodeType === 48 /* StringList */) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                if (!fileInfo.isStubFile && fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_10) {
-                    addError(localize_1.Localizer.Diagnostic.stringNotSubscriptable(), node.baseExpression);
-                }
+                addError(localize_1.Localizer.Diagnostic.stringNotSubscriptable(), node.baseExpression);
             }
         }
         // Check for builtin classes that will generate runtime exceptions if subscripted.
@@ -4487,6 +4539,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 if ((0, types_1.isParamSpec)(typeArg)) {
                                     functionType.details.paramSpec = typeArg;
                                 }
+                                else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
+                                    types_1.FunctionType.addDefaultParameters(functionType);
+                                    functionType.details.flags |= 32768 /* SkipArgsKwargsCompatibilityCheck */;
+                                }
                             }
                             else {
                                 types_1.FunctionType.addParameter(functionType, {
@@ -4601,7 +4657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const itemMethodType = getTypeOfClassMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
                     /* usage */ undefined, 
                     /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */);
-                    if (flags & 256 /* ExpectingTypeAnnotation */) {
+                    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({
                             name: printType(types_1.ClassType.cloneAsInstance(concreteSubtype)),
@@ -4653,9 +4709,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Inlined TypedDicts are supported only for 'dict' (and not for 'Dict').
                 // This feature is currently experimental.
                 const supportsTypedDictTypeArg = AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures &&
-                    (0, types_1.isInstantiableClass)(concreteSubtype) &&
-                    types_1.ClassType.isBuiltIn(concreteSubtype, 'dict') &&
-                    !concreteSubtype.aliasName;
+                    types_1.ClassType.isBuiltIn(concreteSubtype, ['dict', 'TypedDict']) &&
+                    !types_1.ClassType.isBuiltIn(concreteSubtype, 'Dict');
                 let typeArgs = getTypeArgs(node, flags, {
                     isAnnotatedClass,
                     hasCustomClassGetItem: hasCustomClassGetItem || !isGenericClass,
@@ -4866,14 +4921,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeof valueType.literalValue === 'number') {
                 const indexValue = valueType.literalValue;
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
-                if (tupleType && tupleType.tupleTypeArguments && !(0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
-                    if (indexValue >= 0 && indexValue < tupleType.tupleTypeArguments.length) {
-                        return { type: tupleType.tupleTypeArguments[indexValue].type };
-                    }
-                    else if (indexValue < 0 && tupleType.tupleTypeArguments.length + indexValue >= 0) {
-                        return {
-                            type: tupleType.tupleTypeArguments[tupleType.tupleTypeArguments.length + indexValue].type,
-                        };
+                if (tupleType && tupleType.tupleTypeArguments) {
+                    if ((0, typeUtils_1.isTupleIndexUnambiguous)(tupleType, indexValue)) {
+                        if (indexValue >= 0 && indexValue < tupleType.tupleTypeArguments.length) {
+                            return { type: tupleType.tupleTypeArguments[indexValue].type };
+                        }
+                        else if (indexValue < 0 && tupleType.tupleTypeArguments.length + indexValue >= 0) {
+                            return {
+                                type: tupleType.tupleTypeArguments[tupleType.tupleTypeArguments.length + indexValue]
+                                    .type,
+                            };
+                        }
                     }
                 }
             }
@@ -5623,7 +5681,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.arguments.length > 2) {
             addError(localize_1.Localizer.Diagnostic.superCallArgCount(), node.arguments[2]);
         }
-        const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
+        const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
+        const enclosingClass = enclosingFunction
+            ? ParseTreeUtils.getEnclosingClass(enclosingFunction, /* stopAtFunction */ true)
+            : undefined;
         const enclosingClassType = enclosingClass ? (_a = getTypeOfClass(enclosingClass)) === null || _a === void 0 ? void 0 : _a.classType : undefined;
         // Determine which class the "super" call is applied to. If
         // there is no first argument, then the class is implicit.
@@ -5663,7 +5724,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if ((0, types_1.isInstantiableClass)(secondArgType)) {
                 if ((0, types_1.isInstantiableClass)(targetClassType)) {
-                    if (!(0, typeUtils_1.derivesFromClassRecursive)(secondArgType, targetClassType, /* ignoreUnknown */ true)) {
+                    if (!types_1.ClassType.isBuiltIn(targetClassType, 'type') &&
+                        !(0, typeUtils_1.derivesFromClassRecursive)(secondArgType, targetClassType, /* ignoreUnknown */ true)) {
                         reportError = true;
                     }
                 }
@@ -5793,13 +5855,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return argParamCopy;
                     });
                 }
-                // Clone the typeVarContext so we don't modify the original. If this is
-                // not the first time through the loop, clone the type var context
-                // from the previous successful match.
-                const typeVarContextToClone = matchedOverloads.length > 0
-                    ? matchedOverloads[matchedOverloads.length - 1].typeVarContext.clone()
-                    : typeVarContext;
-                const effectiveTypeVarContext = (_a = typeVarContextToClone === null || typeVarContextToClone === void 0 ? void 0 : typeVarContextToClone.clone()) !== null && _a !== void 0 ? _a : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
+                // Clone the typeVarContext so we don't modify the original.
+                const effectiveTypeVarContext = (_a = typeVarContext === null || typeVarContext === void 0 ? void 0 : typeVarContext.clone()) !== null && _a !== void 0 ? _a : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
                 effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(overload));
                 effectiveTypeVarContext.unlock();
                 // Use speculative mode so we don't output any diagnostics or
@@ -6294,23 +6351,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        let effectiveTypeVarContext = typeVarContext;
+        if (!effectiveTypeVarContext) {
+            // If a typeVarContext wasn't provided by the caller, allocate one here.
+            effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(expandedCallType));
+        }
         // The stdlib collections/__init__.pyi stub file defines namedtuple
         // as a function rather than a class, so we need to check for it here.
         if (expandedCallType.details.builtInName === 'namedtuple') {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUntypedNamedTuple, diagnosticRules_1.DiagnosticRule.reportUntypedNamedTuple, localize_1.Localizer.Diagnostic.namedTupleNoTypes(), errorNode);
-            return {
+            const result = {
                 returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ false),
             };
+            validateFunctionArguments(errorNode, argList, { type: expandedCallType }, effectiveTypeVarContext, skipUnknownArgCheck);
+            return result;
         }
         // Handle the NewType specially, replacing the normal return type.
         if (expandedCallType.details.builtInName === 'NewType') {
             return { returnType: createNewType(errorNode, argList) };
         }
-        let effectiveTypeVarContext = typeVarContext;
-        if (!effectiveTypeVarContext) {
-            // If a typeVarContext wasn't provided by the caller, allocate one here.
-            effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(expandedCallType));
-        }
         const functionResult = validateFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         let isTypeIncomplete = !!functionResult.isTypeIncomplete;
         let returnType = functionResult.returnType;
@@ -6437,9 +6496,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (className === 'NamedTuple') {
-                return {
+                const result = {
                     returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ true),
                 };
+                const initTypeResult = getTypeOfObjectMember(errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), '__init__');
+                if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
+                    validateOverloadedFunctionArguments(errorNode, argList, { type: initTypeResult.type }, 
+                    /* typeVarContext */ undefined, skipUnknownArgCheck, 
+                    /* inferenceContext */ undefined);
+                }
+                return result;
             }
             if (className === 'NewType') {
                 return { returnType: createNewType(errorNode, argList) };
@@ -6537,7 +6603,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a, _b;
         const memberType = (_a = getTypeOfObjectMember(errorNode, expandedCallType, '__call__', 
         /* usage */ undefined, 
-        /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
+        /* diag */ undefined, 64 /* 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),
@@ -7940,6 +8006,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* ArgsList */);
                 const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* KwargsDict */);
                 const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+                const nestedArgList = [];
                 argList.forEach((arg) => {
                     var _a;
                     if (arg.argumentCategory === 0 /* Simple */) {
@@ -7969,6 +8036,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             else if (argsParam) {
                                 paramType = argsParam.type;
                             }
+                            else if (paramSpecType.details.paramSpec) {
+                                nestedArgList.push(arg);
+                            }
                             else {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, paramSpecParams.length === 1
                                     ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
@@ -8014,6 +8084,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 });
+                // Handle recursive ParamSpecs.
+                if (paramSpecType.details.paramSpec) {
+                    const boundTypeForParamSpec = srcTypeVarContext
+                        .getPrimarySignature()
+                        .getParamSpecType(paramSpecType.details.paramSpec);
+                    if (boundTypeForParamSpec) {
+                        const paramSpecArgResult = validateFunctionArgumentsForParamSpec(errorNode, nestedArgList, paramSpecType.details.paramSpec, srcTypeVarContext, conditionFilter);
+                        if (paramSpecArgResult.argumentErrors) {
+                            reportedArgError = true;
+                        }
+                    }
+                }
             });
         }
         // Report any missing parameters.
@@ -8051,10 +8133,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isCompatible = true;
         const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.name;
         let skippedBareTypeVarExpectedType = false;
+        let skipSolveTypeVars = false;
         if (argParam.argument.valueExpression) {
             let expectedType;
-            const isBareTypeVarExpectedType = (0, types_1.isTypeVar)(argParam.paramType) && argParam.paramType.scopeId === (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId);
-            if (!options.skipBareTypeVarExpectedType || !isBareTypeVarExpectedType) {
+            // Is the expected type a "bare" in-scope TypeVar or a union of bare in-scope TypeVars?
+            let isExpectedTypeBareTypeVar = true;
+            (0, typeUtils_1.doForEachSubtype)(argParam.paramType, (subtype) => {
+                if (!(0, types_1.isTypeVar)(subtype) || subtype.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
+                    isExpectedTypeBareTypeVar = false;
+                }
+            });
+            if (!options.skipBareTypeVarExpectedType || !isExpectedTypeBareTypeVar) {
                 expectedType = argParam.paramType;
                 // If the parameter type is a function with a ParamSpec, don't apply
                 // the solved TypeVars if the typeVarContext has more than one signature.
@@ -8070,6 +8159,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else {
                 skippedBareTypeVarExpectedType = true;
+                // If the expected type is a union of bare TypeVars, it's not clear which of the two
+                // (or both) should be constrained. We'll skip any attempt to solve the TypeVars during
+                // this pass and hope that subsequent arg assignments will help us establish the correct
+                // constraints.
+                if ((0, types_1.isUnion)(argParam.paramType)) {
+                    skipSolveTypeVars = true;
+                }
             }
             // If the expected type is unknown, don't use an expected type. Instead,
             // use default rules for evaluating the expression type.
@@ -8186,7 +8282,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 if ((0, types_1.isClassInstance)(argType)) {
-                    const callMember = (0, typeUtils_1.lookUpObjectMember)(argType, '__call__');
+                    const callMember = (0, typeUtils_1.lookUpObjectMember)(argType, '__call__', 8 /* SkipInstanceVariables */);
                     if (callMember) {
                         const memberType = getTypeOfMember(callMember);
                         if ((0, types_1.isOverloadedFunction)(memberType)) {
@@ -8203,7 +8299,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        if (!assignType(argParam.paramType, argType, diag.createAddendum(), typeVarContext)) {
+        if (!assignType(argParam.paramType, argType, diag.createAddendum(), typeVarContext, 
+        /* srcTypeVarContext */ undefined, skipSolveTypeVars ? 8 /* SkipSolveTypeVars */ : undefined)) {
             // Mismatching parameter types are common in untyped code; don't bother spending time
             // printing types if the diagnostic is disabled.
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
@@ -8637,7 +8734,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeParameters = [];
             let isTypeParamListValid = true;
             typeParamsExpr.expressions.map((expr) => {
-                let entryType = getTypeOfExpression(expr, 128 /* ExpectingInstantiableType */).type;
+                let entryType = getTypeOfExpression(expr, 128 /* ExpectingInstantiableType */ | 4096 /* AllowTypeVarsWithoutScopeId */).type;
                 if ((0, types_1.isTypeVar)(entryType)) {
                     if (entryType.scopeId) {
                         isTypeParamListValid = false;
@@ -8937,7 +9034,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfDictionaryWithContext(node, inferenceContext, expectedDiagAddendum) {
         inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
-        const concreteExpectedType = makeTopLevelTypeVarsConcrete(inferenceContext.expectedType);
+        let concreteExpectedType = makeTopLevelTypeVarsConcrete(inferenceContext.expectedType);
         if (!(0, types_1.isClassInstance)(concreteExpectedType)) {
             return undefined;
         }
@@ -8946,6 +9043,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = false;
         // Handle TypedDict's as a special case.
         if (types_1.ClassType.isTypedDictClass(concreteExpectedType)) {
+            // Remove any conditions associated with the type so the resulting type isn't
+            // considered compatible with a bound TypeVar.
+            concreteExpectedType = types_1.TypeBase.cloneForCondition(concreteExpectedType, undefined);
             const expectedTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, concreteExpectedType);
             // Infer the key and value types if possible.
             if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
@@ -8955,17 +9055,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* expectedValueType */ undefined, expectedTypedDictEntries, expectedDiagAddendum)) {
                 isIncomplete = true;
             }
-            if (types_1.ClassType.isTypedDictClass(concreteExpectedType)) {
-                const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, concreteExpectedType, keyTypes, valueTypes, 
-                // Don't overwrite existing expectedDiagAddendum messages if they were
-                // already provided by getKeyValueTypesFromDictionary.
-                (expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.isEmpty()) ? expectedDiagAddendum : undefined);
-                if (resultTypedDict) {
-                    return {
-                        type: resultTypedDict,
-                        isIncomplete,
-                    };
-                }
+            const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, concreteExpectedType, keyTypes, valueTypes, 
+            // Don't overwrite existing expectedDiagAddendum messages if they were
+            // already provided by getKeyValueTypesFromDictionary.
+            (expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.isEmpty()) ? expectedDiagAddendum : undefined);
+            if (resultTypedDict) {
+                return {
+                    type: resultTypedDict,
+                    isIncomplete,
+                };
             }
             return undefined;
         }
@@ -9901,6 +9999,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 if ((0, types_1.isParamSpec)(typeArg)) {
                                     functionType.details.paramSpec = typeArg;
                                 }
+                                else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
+                                    types_1.FunctionType.addDefaultParameters(functionType);
+                                    functionType.details.flags |= 32768 /* SkipArgsKwargsCompatibilityCheck */;
+                                }
                             }
                             else {
                                 types_1.FunctionType.addParameter(functionType, {
@@ -10279,7 +10381,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             typeArgs.forEach((typeArg, index) => {
                 if (index === typeArgs.length - 1) {
-                    if (!(0, types_1.isParamSpec)(typeArg.type)) {
+                    if (!(0, types_1.isParamSpec)(typeArg.type) && !(0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         addError(localize_1.Localizer.Diagnostic.concatenateParamSpecMissing(), typeArg.node);
                     }
                 }
@@ -10337,7 +10439,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeArgs.forEach((typeArg, index) => {
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         if (!isTupleTypeParam) {
-                            addError(localize_1.Localizer.Diagnostic.ellipsisContext(), typeArg.node);
+                            if (!allowParamSpec) {
+                                addError(localize_1.Localizer.Diagnostic.ellipsisContext(), typeArg.node);
+                            }
                         }
                         else if (typeArgs.length !== 2 || index !== 1) {
                             addError(localize_1.Localizer.Diagnostic.ellipsisSecondArg(), typeArg.node);
@@ -10555,7 +10659,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
             }), errorNode);
         }
-        return types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
+        const typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
+        // All PEP 695 type aliases are special forms because they are
+        // TypeAliasType objects at runtime.
+        if (isPep695Syntax) {
+            typeAlias.flags |= 8 /* SpecialForm */;
+        }
+        return typeAlias;
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -10583,7 +10693,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // methods that are abstract are overridden and shouldn't
                 // cause the TypedDict to be marked as abstract.
                 if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
-                    baseClass.details.flags &= ~1024 /* SupportsAbstractMethods */;
+                    baseClass = types_1.ClassType.cloneWithNewFlags(baseClass, baseClass.details.flags &
+                        ~(1024 /* SupportsAbstractMethods */ | 134217728 /* TypeCheckOnly */));
                 }
             }
         }
@@ -10701,7 +10812,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function evaluateTypesForAssignmentStatement(node) {
-        var _a;
+        var _a, _b;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // If the entire statement has already been evaluated, don't
         // re-evaluate it.
@@ -10800,20 +10911,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         srcType = types_1.ClassType.cloneWithLiteral(boolType, constExprValue);
                     }
                 }
-                // If there was a declared type, make sure the RHS value is compatible.
-                if (declaredType) {
-                    if (assignType(declaredType, srcType)) {
-                        // Narrow the resulting type if possible.
-                        if (!(0, types_1.isAnyOrUnknown)(srcType)) {
-                            srcType = narrowTypeBasedOnAssignment(node, declaredType, srcType);
-                        }
-                    }
-                }
                 // If this is an enum, transform the type as required.
                 rightHandType = srcType;
                 if (node.leftExpression.nodeType === 38 /* Name */ && !node.typeAnnotationComment) {
                     rightHandType =
-                        (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node.leftExpression, () => rightHandType) || rightHandType;
+                        (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node.leftExpression, () => rightHandType)) !== null && _a !== void 0 ? _a : rightHandType;
                 }
                 if (typeAliasNameNode) {
                     // If this was a speculative type alias, it becomes a real type alias
@@ -10834,7 +10936,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         typeAliasTypeVar.details.boundType = rightHandType;
                         // Record the type parameters within the recursive type alias so it
                         // can be specialized.
-                        typeAliasTypeVar.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
+                        typeAliasTypeVar.details.recursiveTypeParameters = (_b = rightHandType.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.typeParameters;
                     }
                 }
             }
@@ -10998,447 +11100,465 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setSymbolResolutionPartialType(classSymbol, classDecl, classType);
         }
         classType.details.flags |= 131072 /* PartiallyEvaluated */;
-        writeTypeCache(node, { type: classType }, /* flags */ undefined);
-        writeTypeCache(node.name, { type: classType }, /* flags */ undefined);
-        // Keep a list of unique type parameters that are used in the
-        // base class arguments.
-        let typeParameters = [];
-        if (node.typeParameters) {
-            typeParameters = evaluateTypeParameterList(node.typeParameters).map((t) => types_1.TypeVarType.cloneAsInstance(t));
-        }
-        // If the class derives from "Generic" directly, it will provide
-        // all of the type parameters in the specified order.
-        let genericTypeParameters;
-        let protocolTypeParameters;
-        const initSubclassArgs = [];
-        let metaclassNode;
-        let exprFlags = 128 /* ExpectingInstantiableType */ |
-            1024 /* AllowGenericClassType */ |
-            262144 /* DisallowNakedGeneric */ |
-            2048 /* DisallowTypeVarsWithScopeId */ |
-            8192 /* AssociateTypeVarsWithCurrentScope */ |
-            16384 /* EnforceTypeVarVarianceConsistency */ |
-            16777216 /* DisallowPep695TypeAlias */;
-        if (fileInfo.isStubFile) {
-            exprFlags |= 4 /* AllowForwardReferences */;
-        }
-        node.arguments.forEach((arg) => {
-            // Ignore unpacked arguments.
-            if (arg.argumentCategory === 2 /* UnpackedDictionary */) {
-                // Evaluate the expression's type so symbols are marked accessed
-                // and errors are reported.
-                getTypeOfExpression(arg.valueExpression);
-                return;
+        try {
+            writeTypeCache(node, { type: classType }, /* flags */ undefined);
+            writeTypeCache(node.name, { type: classType }, /* flags */ undefined);
+            // Keep a list of unique type parameters that are used in the
+            // base class arguments.
+            let typeParameters = [];
+            if (node.typeParameters) {
+                typeParameters = evaluateTypeParameterList(node.typeParameters).map((t) => types_1.TypeVarType.cloneAsInstance(t));
+            }
+            // If the class derives from "Generic" directly, it will provide
+            // all of the type parameters in the specified order.
+            let genericTypeParameters;
+            let protocolTypeParameters;
+            const initSubclassArgs = [];
+            let metaclassNode;
+            let exprFlags = 128 /* ExpectingInstantiableType */ |
+                1024 /* AllowGenericClassType */ |
+                262144 /* DisallowNakedGeneric */ |
+                2048 /* DisallowTypeVarsWithScopeId */ |
+                8192 /* AssociateTypeVarsWithCurrentScope */ |
+                16384 /* EnforceTypeVarVarianceConsistency */ |
+                16777216 /* DisallowPep695TypeAlias */;
+            if (fileInfo.isStubFile) {
+                exprFlags |= 4 /* AllowForwardReferences */;
             }
-            if (!arg.name) {
-                let argType;
-                if (arg.argumentCategory === 1 /* UnpackedList */) {
+            node.arguments.forEach((arg) => {
+                // Ignore unpacked arguments.
+                if (arg.argumentCategory === 2 /* UnpackedDictionary */) {
+                    // Evaluate the expression's type so symbols are marked accessed
+                    // and errors are reported.
                     getTypeOfExpression(arg.valueExpression);
-                    argType = types_1.UnknownType.create();
+                    return;
                 }
-                else {
-                    argType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(arg.valueExpression, exprFlags).type);
-                }
-                // In some stub files, classes are conditionally defined (e.g. based
-                // on platform type). We'll assume that the conditional logic is correct
-                // and strip off the "unbound" union.
-                if ((0, types_1.isUnion)(argType)) {
-                    argType = (0, types_1.removeUnbound)(argType);
-                }
-                if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
-                    if ((0, typeUtils_1.isMetaclassInstance)(argType)) {
-                        (0, debug_1.assert)((0, types_1.isClassInstance)(argType));
-                        argType =
-                            argType.typeArguments && argType.typeArguments.length > 0
-                                ? argType.typeArguments[0]
-                                : types_1.UnknownType.create();
-                    }
-                    else if (!(0, types_1.isInstantiableClass)(argType)) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.baseClassInvalid(), arg);
+                if (!arg.name) {
+                    let argType;
+                    if (arg.argumentCategory === 1 /* UnpackedList */) {
+                        getTypeOfExpression(arg.valueExpression);
                         argType = types_1.UnknownType.create();
                     }
                     else {
-                        if (types_1.ClassType.isPartiallyEvaluated(argType) ||
-                            argType.details.mro.some((t) => (0, types_1.isClass)(t) && types_1.ClassType.isPartiallyEvaluated(t))) {
-                            // If the base class is partially evaluated, install a callback
-                            // so we can fix up this class (e.g. compute the MRO) when the
-                            // dependent class is completed.
-                            registerDeferredClassCompletion(node, argType);
+                        argType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(arg.valueExpression, exprFlags).type);
+                    }
+                    // In some stub files, classes are conditionally defined (e.g. based
+                    // on platform type). We'll assume that the conditional logic is correct
+                    // and strip off the "unbound" union.
+                    if ((0, types_1.isUnion)(argType)) {
+                        argType = (0, types_1.removeUnbound)(argType);
+                    }
+                    if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
+                        if ((0, typeUtils_1.isMetaclassInstance)(argType)) {
+                            (0, debug_1.assert)((0, types_1.isClassInstance)(argType));
+                            argType =
+                                argType.typeArguments && argType.typeArguments.length > 0
+                                    ? argType.typeArguments[0]
+                                    : types_1.UnknownType.create();
                         }
-                        if (types_1.ClassType.isBuiltIn(argType, 'Protocol')) {
-                            if (!fileInfo.isStubFile &&
-                                !types_1.ClassType.isTypingExtensionClass(argType) &&
-                                fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_7) {
-                                addError(localize_1.Localizer.Diagnostic.protocolIllegal(), arg.valueExpression);
+                        else if (!(0, types_1.isInstantiableClass)(argType)) {
+                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.baseClassInvalid(), arg);
+                            argType = types_1.UnknownType.create();
+                        }
+                        else {
+                            if (types_1.ClassType.isPartiallyEvaluated(argType) ||
+                                argType.details.mro.some((t) => (0, types_1.isClass)(t) && types_1.ClassType.isPartiallyEvaluated(t))) {
+                                // If the base class is partially evaluated, install a callback
+                                // so we can fix up this class (e.g. compute the MRO) when the
+                                // dependent class is completed.
+                                registerDeferredClassCompletion(node, argType);
+                            }
+                            if (types_1.ClassType.isBuiltIn(argType, 'Protocol')) {
+                                if (!fileInfo.isStubFile &&
+                                    !types_1.ClassType.isTypingExtensionClass(argType) &&
+                                    fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_7) {
+                                    addError(localize_1.Localizer.Diagnostic.protocolIllegal(), arg.valueExpression);
+                                }
+                                classType.details.flags |= 8192 /* ProtocolClass */;
+                            }
+                            if (types_1.ClassType.isBuiltIn(argType, 'property')) {
+                                classType.details.flags |= 2048 /* PropertyClass */;
+                            }
+                            // If the class directly derives from NamedTuple (in Python 3.6 or
+                            // newer), it's considered a (read-only) dataclass.
+                            if (fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_6) {
+                                if (types_1.ClassType.isBuiltIn(argType, 'NamedTuple')) {
+                                    classType.details.flags |=
+                                        4 /* DataClass */ |
+                                            32 /* SkipSynthesizedDataClassEq */ |
+                                            16777216 /* ReadOnlyInstanceVariables */;
+                                }
+                            }
+                            // If the class directly derives from TypedDict or from a class that is
+                            // a TypedDict, it is considered a TypedDict.
+                            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)) {
+                                addError(localize_1.Localizer.Diagnostic.baseClassCircular(), arg);
+                                argType = types_1.UnknownType.create();
                             }
-                            classType.details.flags |= 8192 /* ProtocolClass */;
                         }
-                        if (types_1.ClassType.isBuiltIn(argType, 'property')) {
-                            classType.details.flags |= 2048 /* PropertyClass */;
+                    }
+                    if ((0, types_1.isUnknown)(argType)) {
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedBaseClass, diagnosticRules_1.DiagnosticRule.reportUntypedBaseClass, localize_1.Localizer.Diagnostic.baseClassUnknown(), arg);
+                    }
+                    // Check for a duplicate class.
+                    if (classType.details.baseClasses.some((prevBaseClass) => {
+                        return ((0, types_1.isInstantiableClass)(prevBaseClass) &&
+                            (0, types_1.isInstantiableClass)(argType) &&
+                            types_1.ClassType.isSameGenericClass(argType, prevBaseClass));
+                    })) {
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateBaseClass(), arg.name || arg);
+                    }
+                    classType.details.baseClasses.push(argType);
+                    if ((0, types_1.isInstantiableClass)(argType)) {
+                        if (types_1.ClassType.isEnumClass(argType)) {
+                            classType.details.flags |= 1048576 /* EnumClass */;
                         }
-                        // If the class directly derives from NamedTuple (in Python 3.6 or
-                        // newer), it's considered a (read-only) dataclass.
-                        if (fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_6) {
-                            if (types_1.ClassType.isBuiltIn(argType, 'NamedTuple')) {
-                                classType.details.flags |=
-                                    4 /* DataClass */ |
-                                        32 /* SkipSynthesizedDataClassEq */ |
-                                        16777216 /* ReadOnlyInstanceVariables */;
-                            }
+                        // Determine if the class is abstract. Protocol classes support abstract methods
+                        // even though they don't derive from the ABCMeta class. We'll exclude built-in
+                        // protocol classes because these are known not to contain any abstract methods
+                        // and getAbstractMethods causes problems because of dependencies on some of these
+                        // built-in protocol classes.
+                        if (types_1.ClassType.supportsAbstractMethods(argType) ||
+                            (types_1.ClassType.isProtocolClass(argType) && !types_1.ClassType.isBuiltIn(argType))) {
+                            classType.details.flags |= 1024 /* SupportsAbstractMethods */;
+                        }
+                        if (types_1.ClassType.isPropertyClass(argType)) {
+                            classType.details.flags |= 2048 /* PropertyClass */;
                         }
-                        // If the class directly derives from TypedDict or from a class that is
-                        // a TypedDict, it is considered a TypedDict.
-                        if (types_1.ClassType.isBuiltIn(argType, 'TypedDict') || types_1.ClassType.isTypedDictClass(argType)) {
-                            classType.details.flags |= 128 /* TypedDictClass */;
+                        if (types_1.ClassType.isFinal(argType)) {
+                            const className = printObjectTypeForClass(argType);
+                            addError(localize_1.Localizer.Diagnostic.baseClassFinal().format({ type: className }), arg.valueExpression);
                         }
-                        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);
+                    }
+                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
+                    if ((0, types_1.isInstantiableClass)(argType)) {
+                        if (types_1.ClassType.isBuiltIn(argType, 'Generic')) {
+                            // 'Generic' is implicitly added if type parameter syntax is used.
+                            if (node.typeParameters) {
+                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericBaseClassNotAllowed(), arg.valueExpression);
+                            }
+                            else {
+                                if (!genericTypeParameters) {
+                                    if (protocolTypeParameters) {
+                                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateGenericAndProtocolBase(), arg.valueExpression);
+                                    }
+                                    genericTypeParameters = [];
+                                    (0, typeUtils_1.addTypeVarsToListIfUnique)(genericTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
+                                }
                             }
                         }
-                        // Validate that the class isn't deriving from itself, creating a
-                        // circular dependency.
-                        if ((0, typeUtils_1.derivesFromClassRecursive)(argType, classType, /* ignoreUnknown */ true)) {
-                            addError(localize_1.Localizer.Diagnostic.baseClassCircular(), arg);
-                            argType = types_1.UnknownType.create();
+                        else if (types_1.ClassType.isBuiltIn(argType, 'Protocol') &&
+                            argType.typeArguments &&
+                            argType.typeArguments.length > 0) {
+                            if (!protocolTypeParameters) {
+                                if (genericTypeParameters) {
+                                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateGenericAndProtocolBase(), arg.valueExpression);
+                                }
+                                protocolTypeParameters = [];
+                                (0, typeUtils_1.addTypeVarsToListIfUnique)(protocolTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
+                                if (node.typeParameters && protocolTypeParameters.length > 0) {
+                                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolBaseClassWithTypeArgs(), arg.valueExpression);
+                                    protocolTypeParameters = [];
+                                }
+                            }
                         }
                     }
                 }
-                if ((0, types_1.isUnknown)(argType)) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedBaseClass, diagnosticRules_1.DiagnosticRule.reportUntypedBaseClass, localize_1.Localizer.Diagnostic.baseClassUnknown(), arg);
-                }
-                // Check for a duplicate class.
-                if (classType.details.baseClasses.some((prevBaseClass) => {
-                    return ((0, types_1.isInstantiableClass)(prevBaseClass) &&
-                        (0, types_1.isInstantiableClass)(argType) &&
-                        types_1.ClassType.isSameGenericClass(argType, prevBaseClass));
-                })) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateBaseClass(), arg.name || arg);
-                }
-                classType.details.baseClasses.push(argType);
-                if ((0, types_1.isInstantiableClass)(argType)) {
-                    if (types_1.ClassType.isEnumClass(argType)) {
-                        classType.details.flags |= 1048576 /* EnumClass */;
+                else if (arg.name.value === 'metaclass') {
+                    if (metaclassNode) {
+                        addError(localize_1.Localizer.Diagnostic.metaclassDuplicate(), arg);
+                    }
+                    else {
+                        metaclassNode = arg.valueExpression;
                     }
-                    // Determine if the class is abstract. Protocol classes support abstract methods
-                    // even though they don't derive from the ABCMeta class. We'll exclude built-in
-                    // protocol classes because these are known not to contain any abstract methods
-                    // and getAbstractMethods causes problems because of dependencies on some of these
-                    // built-in protocol classes.
-                    if (types_1.ClassType.supportsAbstractMethods(argType) ||
-                        (types_1.ClassType.isProtocolClass(argType) && !types_1.ClassType.isBuiltIn(argType))) {
-                        classType.details.flags |= 1024 /* SupportsAbstractMethods */;
+                }
+                else if (types_1.ClassType.isTypedDictClass(classType) &&
+                    (arg.name.value === 'total' || arg.name.value === 'readonly')) {
+                    // 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);
+                    if (constArgValue === undefined) {
+                        addError(localize_1.Localizer.Diagnostic.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
                     }
-                    if (types_1.ClassType.isPropertyClass(argType)) {
-                        classType.details.flags |= 2048 /* PropertyClass */;
+                    else if (arg.name.value === 'total' && !constArgValue) {
+                        classType.details.flags |= 256 /* CanOmitDictValues */;
                     }
-                    if (types_1.ClassType.isFinal(argType)) {
-                        const className = printObjectTypeForClass(argType);
-                        addError(localize_1.Localizer.Diagnostic.baseClassFinal().format({ type: className }), arg.valueExpression);
+                    else if (arg.name.value === 'readonly' && constArgValue) {
+                        classType.details.flags |= 512 /* DictValuesReadOnly */;
                     }
                 }
-                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
-                if ((0, types_1.isInstantiableClass)(argType)) {
-                    if (types_1.ClassType.isBuiltIn(argType, 'Generic')) {
-                        // 'Generic' is implicitly added if type parameter syntax is used.
-                        if (node.typeParameters) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericBaseClassNotAllowed(), arg.valueExpression);
+                else {
+                    // Collect arguments that will be passed to the `__init_subclass__`
+                    // method described in PEP 487.
+                    initSubclassArgs.push({
+                        argumentCategory: 0 /* Simple */,
+                        node: arg,
+                        name: arg.name,
+                        valueExpression: arg.valueExpression,
+                    });
+                }
+            });
+            // Check for NamedTuple multiple inheritance.
+            if (classType.details.baseClasses.length > 1) {
+                let derivesFromNamedTuple = false;
+                let foundIllegalBaseClass = false;
+                classType.details.baseClasses.forEach((baseClass) => {
+                    if ((0, types_1.isInstantiableClass)(baseClass)) {
+                        if (types_1.ClassType.isBuiltIn(baseClass, 'NamedTuple')) {
+                            derivesFromNamedTuple = true;
                         }
-                        else {
-                            if (!genericTypeParameters) {
-                                if (protocolTypeParameters) {
-                                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateGenericAndProtocolBase(), arg.valueExpression);
-                                }
-                                genericTypeParameters = [];
-                                (0, typeUtils_1.addTypeVarsToListIfUnique)(genericTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
-                            }
+                        else if (!types_1.ClassType.isBuiltIn(baseClass, 'Generic')) {
+                            foundIllegalBaseClass = true;
                         }
                     }
-                    else if (types_1.ClassType.isBuiltIn(argType, 'Protocol') &&
-                        argType.typeArguments &&
-                        argType.typeArguments.length > 0) {
-                        if (!protocolTypeParameters) {
-                            if (genericTypeParameters) {
-                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateGenericAndProtocolBase(), arg.valueExpression);
-                            }
-                            protocolTypeParameters = [];
-                            (0, typeUtils_1.addTypeVarsToListIfUnique)(protocolTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
-                            if (node.typeParameters && protocolTypeParameters.length > 0) {
-                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolBaseClassWithTypeArgs(), arg.valueExpression);
-                                protocolTypeParameters = [];
+                });
+                if (derivesFromNamedTuple && foundIllegalBaseClass) {
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.namedTupleMultipleInheritance(), node.name);
+                }
+            }
+            // Make sure we don't have 'object' derive from itself. Infinite
+            // recursion will result.
+            if (!types_1.ClassType.isBuiltIn(classType, 'object') &&
+                classType.details.baseClasses.filter((baseClass) => (0, types_1.isClass)(baseClass)).length === 0) {
+                // If there are no other (known) base classes, the class implicitly derives from object.
+                classType.details.baseClasses.push(getBuiltInType(node, 'object'));
+            }
+            // If genericTypeParameters or protocolTypeParameters are provided,
+            // make sure that typeParameters is a proper subset.
+            genericTypeParameters = genericTypeParameters !== null && genericTypeParameters !== void 0 ? genericTypeParameters : protocolTypeParameters;
+            if (genericTypeParameters && !node.typeParameters) {
+                verifyGenericTypeParameters(node.name, typeParameters, genericTypeParameters);
+            }
+            classType.details.typeParameters = genericTypeParameters !== null && genericTypeParameters !== void 0 ? genericTypeParameters : typeParameters;
+            // Determine if one or more type parameters is autovariance.
+            if (classType.details.typeParameters.some((param) => param.details.declaredVariance === 0 /* Auto */ && param.computedVariance === undefined)) {
+                classType.details.requiresVarianceInference = true;
+            }
+            // Make sure there's at most one variadic type parameter.
+            const variadics = classType.details.typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
+            if (variadics.length > 1) {
+                addError(localize_1.Localizer.Diagnostic.variadicTypeParamTooManyClass().format({
+                    names: variadics.map((v) => `"${v.details.name}"`).join(', '),
+                }), node.name, textRange_1.TextRange.combine(node.arguments) || node.name);
+            }
+            // Validate the default types for all type parameters.
+            classType.details.typeParameters.forEach((typeParam, index) => {
+                var _a;
+                let bestErrorNode = node.name;
+                if (node.typeParameters && index < node.typeParameters.parameters.length) {
+                    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));
+            });
+            if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
+                addError(localize_1.Localizer.Diagnostic.methodOrdering(), node.name);
+            }
+            // The scope for this class becomes the "fields" for the corresponding type.
+            const innerScope = ScopeUtils.getScopeForNode(node.suite);
+            classType.details.fields = (innerScope === null || innerScope === void 0 ? void 0 : innerScope.symbolTable)
+                ? new Map(innerScope.symbolTable)
+                : new Map();
+            // Determine whether the class should inherit __hash__. If a class defines
+            // __eq__ but doesn't define __hash__ then __hash__ is set to None.
+            if (classType.details.fields.has('__eq__') && !classType.details.fields.has('__hash__')) {
+                classType.details.fields.set('__hash__', symbol_1.Symbol.createWithType(4 /* ClassMember */ |
+                    128 /* ClassVar */ |
+                    64 /* IgnoredForProtocolMatch */ |
+                    4096 /* IgnoredForOverrideChecks */, types_1.NoneType.createInstance()));
+            }
+            // Determine whether the class's instance variables are constrained
+            // to those defined by __slots__. We need to do this prior to dataclass
+            // processing because dataclasses can implicitly add to the slots
+            // list.
+            const slotsNames = innerScope === null || innerScope === void 0 ? void 0 : innerScope.getSlotsNames();
+            if (slotsNames) {
+                classType.details.localSlotsNames = slotsNames;
+            }
+            // Determine if the class should be a "pseudo-generic" class, characterized
+            // by having an __init__ method with parameters that lack type annotations.
+            // For such classes, we'll treat them as generic, with the type arguments provided
+            // by the callers of the constructor.
+            if (!fileInfo.isStubFile && classType.details.typeParameters.length === 0) {
+                const initMethod = classType.details.fields.get('__init__');
+                if (initMethod) {
+                    const initDecls = initMethod.getTypedDeclarations();
+                    if (initDecls.length === 1 && initDecls[0].type === 5 /* Function */) {
+                        const initDeclNode = initDecls[0].node;
+                        const initParams = initDeclNode.parameters;
+                        if (initParams.length > 1 &&
+                            !initParams.some((param, index) => !!ParseTreeUtils.getTypeAnnotationForParameter(initDeclNode, index))) {
+                            const genericParams = initParams.filter((param, index) => index > 0 &&
+                                param.name &&
+                                param.category === 0 /* Simple */ &&
+                                !param.defaultValue);
+                            if (genericParams.length > 0) {
+                                classType.details.flags |= 16384 /* PseudoGenericClass */;
+                                // Create a type parameter for each simple, named parameter
+                                // in the __init__ method.
+                                classType.details.typeParameters = genericParams.map((param) => {
+                                    const typeVar = types_1.TypeVarType.createInstance(getPseudoGenericTypeVarName(param.name.value));
+                                    typeVar.details.isSynthesized = true;
+                                    typeVar.scopeId = ParseTreeUtils.getScopeIdForNode(initDeclNode);
+                                    typeVar.details.boundType = types_1.UnknownType.create();
+                                    return types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(node), node.name.value, 0 /* Class */);
+                                });
                             }
                         }
                     }
                 }
             }
-            else if (arg.name.value === 'metaclass') {
-                if (metaclassNode) {
-                    addError(localize_1.Localizer.Diagnostic.metaclassDuplicate(), arg);
-                }
-                else {
-                    metaclassNode = arg.valueExpression;
-                }
-            }
-            else if (types_1.ClassType.isTypedDictClass(classType) &&
-                (arg.name.value === 'total' || arg.name.value === 'readonly')) {
-                // 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);
-                if (constArgValue === undefined) {
-                    addError(localize_1.Localizer.Diagnostic.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
+            // Determine if the class has a custom __class_getitem__ method. This applies
+            // only to classes that have no type parameters, since those with type parameters
+            // are assumed to follow normal subscripting semantics for generic classes.
+            if (classType.details.typeParameters.length === 0 && !types_1.ClassType.isBuiltIn(classType, 'type')) {
+                if (classType.details.baseClasses.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.hasCustomClassGetItem(baseClass)) ||
+                    classType.details.fields.has('__class_getitem__')) {
+                    classType.details.flags |= 262144 /* HasCustomClassGetItem */;
                 }
-                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__`
-                // method described in PEP 487.
-                initSubclassArgs.push({
-                    argumentCategory: 0 /* Simple */,
-                    node: arg,
-                    name: arg.name,
-                    valueExpression: arg.valueExpression,
-                });
             }
-        });
-        // Check for NamedTuple multiple inheritance.
-        if (classType.details.baseClasses.length > 1) {
-            let derivesFromNamedTuple = false;
-            let foundIllegalBaseClass = false;
-            classType.details.baseClasses.forEach((baseClass) => {
-                if ((0, types_1.isInstantiableClass)(baseClass)) {
-                    if (types_1.ClassType.isBuiltIn(baseClass, 'NamedTuple')) {
-                        derivesFromNamedTuple = true;
+            // Determine the effective metaclass.
+            if (metaclassNode) {
+                const metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
+                if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
+                    if ((0, typeUtils_1.requiresSpecialization)(metaclassType, /* ignorePseudoGeneric */ true)) {
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.metaclassIsGeneric(), metaclassNode);
                     }
-                    else if (!types_1.ClassType.isBuiltIn(baseClass, 'Generic')) {
-                        foundIllegalBaseClass = true;
-                    }
-                }
-            });
-            if (derivesFromNamedTuple && foundIllegalBaseClass) {
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.namedTupleMultipleInheritance(), node.name);
-            }
-        }
-        // Make sure we don't have 'object' derive from itself. Infinite
-        // recursion will result.
-        if (!types_1.ClassType.isBuiltIn(classType, 'object') &&
-            classType.details.baseClasses.filter((baseClass) => (0, types_1.isClass)(baseClass)).length === 0) {
-            // If there are no other (known) base classes, the class implicitly derives from object.
-            classType.details.baseClasses.push(getBuiltInType(node, 'object'));
-        }
-        // If genericTypeParameters or protocolTypeParameters are provided,
-        // make sure that typeParameters is a proper subset.
-        genericTypeParameters = genericTypeParameters !== null && genericTypeParameters !== void 0 ? genericTypeParameters : protocolTypeParameters;
-        if (genericTypeParameters && !node.typeParameters) {
-            verifyGenericTypeParameters(node.name, typeParameters, genericTypeParameters);
-        }
-        classType.details.typeParameters = genericTypeParameters !== null && genericTypeParameters !== void 0 ? genericTypeParameters : typeParameters;
-        // Determine if one or more type parameters is autovariance.
-        if (classType.details.typeParameters.some((param) => param.details.declaredVariance === 0 /* Auto */ && param.computedVariance === undefined)) {
-            classType.details.requiresVarianceInference = true;
-        }
-        // Make sure there's at most one variadic type parameter.
-        const variadics = classType.details.typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
-        if (variadics.length > 1) {
-            addError(localize_1.Localizer.Diagnostic.variadicTypeParamTooManyClass().format({
-                names: variadics.map((v) => `"${v.details.name}"`).join(', '),
-            }), node.name, textRange_1.TextRange.combine(node.arguments) || node.name);
-        }
-        // Validate the default types for all type parameters.
-        classType.details.typeParameters.forEach((typeParam, index) => {
-            var _a;
-            let bestErrorNode = node.name;
-            if (node.typeParameters && index < node.typeParameters.parameters.length) {
-                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));
-        });
-        if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
-            addError(localize_1.Localizer.Diagnostic.methodOrdering(), node.name);
-        }
-        // The scope for this class becomes the "fields" for the corresponding type.
-        const innerScope = ScopeUtils.getScopeForNode(node.suite);
-        classType.details.fields = (innerScope === null || innerScope === void 0 ? void 0 : innerScope.symbolTable)
-            ? new Map(innerScope.symbolTable)
-            : new Map();
-        // Determine whether the class's instance variables are constrained
-        // to those defined by __slots__. We need to do this prior to dataclass
-        // processing because dataclasses can implicitly add to the slots
-        // list.
-        const slotsNames = innerScope === null || innerScope === void 0 ? void 0 : innerScope.getSlotsNames();
-        if (slotsNames) {
-            classType.details.localSlotsNames = slotsNames;
-        }
-        // Determine if the class should be a "pseudo-generic" class, characterized
-        // by having an __init__ method with parameters that lack type annotations.
-        // For such classes, we'll treat them as generic, with the type arguments provided
-        // by the callers of the constructor.
-        if (!fileInfo.isStubFile && classType.details.typeParameters.length === 0) {
-            const initMethod = classType.details.fields.get('__init__');
-            if (initMethod) {
-                const initDecls = initMethod.getTypedDeclarations();
-                if (initDecls.length === 1 && initDecls[0].type === 5 /* Function */) {
-                    const initDeclNode = initDecls[0].node;
-                    const initParams = initDeclNode.parameters;
-                    if (initParams.length > 1 &&
-                        !initParams.some((param, index) => !!ParseTreeUtils.getTypeAnnotationForParameter(initDeclNode, index))) {
-                        const genericParams = initParams.filter((param, index) => index > 0 &&
-                            param.name &&
-                            param.category === 0 /* Simple */ &&
-                            !param.defaultValue);
-                        if (genericParams.length > 0) {
-                            classType.details.flags |= 16384 /* PseudoGenericClass */;
-                            // Create a type parameter for each simple, named parameter
-                            // in the __init__ method.
-                            classType.details.typeParameters = genericParams.map((param) => {
-                                const typeVar = types_1.TypeVarType.createInstance(getPseudoGenericTypeVarName(param.name.value));
-                                typeVar.details.isSynthesized = true;
-                                typeVar.scopeId = ParseTreeUtils.getScopeIdForNode(initDeclNode);
-                                typeVar.details.boundType = types_1.UnknownType.create();
-                                return types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(node), node.name.value, 0 /* Class */);
-                            });
+                    classType.details.declaredMetaclass = metaclassType;
+                    if ((0, types_1.isInstantiableClass)(metaclassType)) {
+                        if (types_1.ClassType.isBuiltIn(metaclassType, 'EnumMeta')) {
+                            classType.details.flags |= 1048576 /* EnumClass */;
+                        }
+                        else if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
+                            classType.details.flags |= 1024 /* SupportsAbstractMethods */;
                         }
                     }
                 }
             }
-        }
-        // Determine if the class has a custom __class_getitem__ method. This applies
-        // only to classes that have no type parameters, since those with type parameters
-        // are assumed to follow normal subscripting semantics for generic classes.
-        if (classType.details.typeParameters.length === 0 && !types_1.ClassType.isBuiltIn(classType, 'type')) {
-            if (classType.details.baseClasses.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.hasCustomClassGetItem(baseClass)) ||
-                classType.details.fields.has('__class_getitem__')) {
-                classType.details.flags |= 262144 /* HasCustomClassGetItem */;
-            }
-        }
-        // Determine the effective metaclass and detect metaclass conflicts.
-        if (metaclassNode) {
-            const metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
-            if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
-                if ((0, typeUtils_1.requiresSpecialization)(metaclassType, /* ignorePseudoGeneric */ true)) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.metaclassIsGeneric(), metaclassNode);
-                }
-                classType.details.declaredMetaclass = metaclassType;
-                if ((0, types_1.isInstantiableClass)(metaclassType)) {
-                    if (types_1.ClassType.isBuiltIn(metaclassType, 'EnumMeta')) {
-                        classType.details.flags |= 1048576 /* EnumClass */;
-                    }
-                    else if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
-                        classType.details.flags |= 1024 /* SupportsAbstractMethods */;
+            const effectiveMetaclass = computeEffectiveMetaclass(classType, node.name);
+            // Clear the "partially constructed" flag.
+            classType.details.flags &= ~131072 /* PartiallyEvaluated */;
+            // Now determine the decorated type of the class.
+            let decoratedType = classType;
+            let foundUnknown = false;
+            for (let i = node.decorators.length - 1; i >= 0; i--) {
+                const decorator = node.decorators[i];
+                const newDecoratedType = (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator);
+                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.reportUntypedClassDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedClassDecorator, localize_1.Localizer.Diagnostic.classDecoratorTypeUnknown(), node.decorators[i].expression);
+                        foundUnknown = true;
                     }
                 }
-            }
-        }
-        const effectiveMetaclass = computeEffectiveMetaclass(classType, node.name);
-        // Clear the "partially constructed" flag.
-        classType.details.flags &= ~131072 /* PartiallyEvaluated */;
-        // Now determine the decorated type of the class.
-        let decoratedType = classType;
-        let foundUnknown = false;
-        for (let i = node.decorators.length - 1; i >= 0; i--) {
-            const decorator = node.decorators[i];
-            const newDecoratedType = (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator);
-            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.reportUntypedClassDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedClassDecorator, localize_1.Localizer.Diagnostic.classDecoratorTypeUnknown(), node.decorators[i].expression);
-                    foundUnknown = true;
+                else {
+                    // Apply the decorator only if the type is known.
+                    decoratedType = newDecoratedType;
                 }
             }
-            else {
-                // Apply the decorator only if the type is known.
-                decoratedType = newDecoratedType;
+            // Determine whether this class derives from (or has a metaclass) that imbues
+            // it with dataclass-like behaviors. If so, we'll apply those here.
+            let dataClassBehaviors;
+            if ((0, types_1.isInstantiableClass)(effectiveMetaclass) && effectiveMetaclass.details.classDataClassTransform) {
+                dataClassBehaviors = effectiveMetaclass.details.classDataClassTransform;
             }
-        }
-        // Determine whether this class derives from (or has a metaclass) that imbues
-        // it with dataclass-like behaviors. If so, we'll apply those here.
-        let dataClassBehaviors;
-        if ((0, types_1.isInstantiableClass)(effectiveMetaclass) && effectiveMetaclass.details.classDataClassTransform) {
-            dataClassBehaviors = effectiveMetaclass.details.classDataClassTransform;
-        }
-        else {
-            const baseClassDataTransform = classType.details.mro.find((mroClass) => {
-                return ((0, types_1.isClass)(mroClass) &&
-                    mroClass.details.classDataClassTransform !== undefined &&
-                    !types_1.ClassType.isSameGenericClass(mroClass, classType));
-            });
-            if (baseClassDataTransform) {
-                dataClassBehaviors = baseClassDataTransform.details.classDataClassTransform;
-            }
-        }
-        if (dataClassBehaviors) {
-            (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
-            (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.name, classType, initSubclassArgs, dataClassBehaviors);
-        }
-        // Run any deferred class completions that depend on this class.
-        runDeferredClassCompletions(classType);
-        // If there are any outstanding deferred class completions registered that
-        // were not removed by the call to runDeferredClassCompletions, assume that
-        // the current class may depend on them and register for deferred completion.
-        registerDeferredClassCompletion(node, /* dependsUpon */ undefined);
-        // Synthesize TypedDict methods.
-        if (types_1.ClassType.isTypedDictClass(classType)) {
-            (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, (0, types_1.isClass)(decoratedType) && types_1.ClassType.isFinal(decoratedType));
-        }
-        // Synthesize dataclass methods.
-        if (types_1.ClassType.isDataClass(classType)) {
-            const skipSynthesizedInit = types_1.ClassType.isSkipSynthesizedDataClassInit(classType);
-            let hasExistingInitMethod = skipSynthesizedInit;
-            // See if there's already a non-synthesized __init__ method.
-            // We shouldn't override it.
-            if (!skipSynthesizedInit) {
-                const initSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 2 /* SkipBaseClasses */);
-                if (initSymbol) {
-                    hasExistingInitMethod = true;
-                }
-            }
-            let skipSynthesizeHash = false;
-            const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 2 /* SkipBaseClasses */);
-            if (hashSymbol) {
-                skipSynthesizeHash = true;
-            }
-            (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
-        }
-        // Build a complete list of all slots names defined by the class hierarchy.
-        // This needs to be done after dataclass processing.
-        if (classType.details.localSlotsNames) {
-            let isLimitedToSlots = true;
-            const extendedSlotsNames = Array.from(classType.details.localSlotsNames);
-            classType.details.baseClasses.forEach((baseClass) => {
-                if ((0, types_1.isInstantiableClass)(baseClass)) {
-                    if (!types_1.ClassType.isBuiltIn(baseClass, 'object') &&
-                        !types_1.ClassType.isBuiltIn(baseClass, 'type') &&
-                        !types_1.ClassType.isBuiltIn(baseClass, 'Generic')) {
-                        if (baseClass.details.inheritedSlotsNames === undefined) {
-                            isLimitedToSlots = false;
-                        }
-                        else {
-                            (0, collectionUtils_1.appendArray)(extendedSlotsNames, baseClass.details.inheritedSlotsNames);
+            else {
+                const baseClassDataTransform = classType.details.mro.find((mroClass) => {
+                    return ((0, types_1.isClass)(mroClass) &&
+                        mroClass.details.classDataClassTransform !== undefined &&
+                        !types_1.ClassType.isSameGenericClass(mroClass, classType));
+                });
+                if (baseClassDataTransform) {
+                    dataClassBehaviors = baseClassDataTransform.details.classDataClassTransform;
+                }
+            }
+            if (dataClassBehaviors) {
+                (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
+                (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.name, classType, initSubclassArgs, dataClassBehaviors);
+            }
+            // Run any deferred class completions that depend on this class.
+            runDeferredClassCompletions(classType);
+            // If there are any outstanding deferred class completions registered that
+            // were not removed by the call to runDeferredClassCompletions, assume that
+            // the current class may depend on them and register for deferred completion.
+            registerDeferredClassCompletion(node, /* dependsUpon */ undefined);
+            // Synthesize TypedDict methods.
+            if (types_1.ClassType.isTypedDictClass(classType)) {
+                (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, (0, types_1.isClass)(decoratedType) && types_1.ClassType.isFinal(decoratedType));
+            }
+            // Synthesize dataclass methods.
+            if (types_1.ClassType.isDataClass(classType)) {
+                const skipSynthesizedInit = types_1.ClassType.isSkipSynthesizedDataClassInit(classType);
+                let hasExistingInitMethod = skipSynthesizedInit;
+                // See if there's already a non-synthesized __init__ method.
+                // We shouldn't override it.
+                if (!skipSynthesizedInit) {
+                    const initSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 2 /* SkipBaseClasses */);
+                    if (initSymbol) {
+                        hasExistingInitMethod = true;
+                    }
+                }
+                let skipSynthesizeHash = false;
+                const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 2 /* SkipBaseClasses */);
+                if (hashSymbol) {
+                    skipSynthesizeHash = true;
+                }
+                (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
+            }
+            // Build a complete list of all slots names defined by the class hierarchy.
+            // This needs to be done after dataclass processing.
+            if (classType.details.localSlotsNames) {
+                let isLimitedToSlots = true;
+                const extendedSlotsNames = Array.from(classType.details.localSlotsNames);
+                classType.details.baseClasses.forEach((baseClass) => {
+                    if ((0, types_1.isInstantiableClass)(baseClass)) {
+                        if (!types_1.ClassType.isBuiltIn(baseClass, 'object') &&
+                            !types_1.ClassType.isBuiltIn(baseClass, 'type') &&
+                            !types_1.ClassType.isBuiltIn(baseClass, 'Generic')) {
+                            if (baseClass.details.inheritedSlotsNames === undefined) {
+                                isLimitedToSlots = false;
+                            }
+                            else {
+                                (0, collectionUtils_1.appendArray)(extendedSlotsNames, baseClass.details.inheritedSlotsNames);
+                            }
                         }
                     }
+                    else {
+                        isLimitedToSlots = false;
+                    }
+                });
+                if (isLimitedToSlots) {
+                    classType.details.inheritedSlotsNames = extendedSlotsNames;
                 }
-                else {
-                    isLimitedToSlots = false;
-                }
-            });
-            if (isLimitedToSlots) {
-                classType.details.inheritedSlotsNames = extendedSlotsNames;
             }
+            // Update the undecorated class type.
+            writeTypeCache(node.name, { type: classType }, 0 /* None */);
+            // Update the decorated class type.
+            writeTypeCache(node, { type: decoratedType }, 0 /* None */);
+            return { classType, decoratedType };
+        }
+        catch (e) {
+            if (cancellationUtils_1.OperationCanceledException.is(e)) {
+                // If the work was canceled before the class types were updated, the
+                // class type in the type cache is in an invalid, partially-constructed state.
+                e.isTypeCacheInvalid = true;
+            }
+            throw e;
         }
-        // Update the undecorated class type.
-        writeTypeCache(node.name, { type: classType }, 0 /* None */);
-        // Update the decorated class type.
-        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
-        return { classType, decoratedType };
     }
     // Determines whether the type parameters has a default that refers to another
     // type parameter. If so, validates that it is in the list of "live" type
@@ -12105,11 +12225,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             validateTypeParameterDefault(bestErrorNode, typeParam, functionType.details.typeParameters.slice(0, index));
         });
+        // 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 */;
-        // If it's an async function, wrap the return type in an Awaitable or Generator.
-        const preDecoratedType = node.isAsync ? createAsyncFunction(node, functionType) : functionType;
         // Apply all of the decorators in reverse order.
         let decoratedType = preDecoratedType;
         let foundUnknown = false;
@@ -12322,7 +12442,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         (0, debug_1.assert)(types_1.FunctionType.isAsync(functionType));
         // Clone the original function and replace its return type with an
         // Awaitable[<returnType>]. Mark the new function as no longer async.
-        const awaitableFunctionType = types_1.FunctionType.cloneWithNewFlags(functionType, functionType.details.flags & ~512 /* Async */);
+        const awaitableFunctionType = types_1.FunctionType.cloneWithNewFlags(functionType, functionType.details.flags & ~(512 /* Async */ | 131072 /* PartiallyEvaluated */));
         if (functionType.details.declaredReturnType) {
             awaitableFunctionType.details.declaredReturnType = createAwaitableReturnType(node, functionType.details.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         }
@@ -12805,7 +12925,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         for (const caseStatement of node.parent.cases) {
             if (caseStatement === node) {
                 if (fileInfo.diagnosticRuleSet.reportUnnecessaryComparison !== 'none') {
-                    (0, patternMatching_1.checkForUnusedPattern)(evaluatorInterface, node.pattern, subjectType);
+                    if (!subjectTypeResult.isIncomplete) {
+                        (0, patternMatching_1.checkForUnusedPattern)(evaluatorInterface, node.pattern, subjectType);
+                    }
                 }
                 break;
             }
@@ -12821,23 +12943,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (isTypeCached(node)) {
             return;
         }
-        // Use the first element of the name parts as the symbol.
-        const symbolNameNode = node.module.nameParts[0];
-        // Look up the symbol to find the alias declaration.
-        let symbolType = getAliasedSymbolTypeForName(node, symbolNameNode.value);
-        if (!symbolType) {
-            return;
+        if (node.isWildcardImport) {
+            // Write back a dummy type so we don't evaluate this node again.
+            writeTypeCache(node, { type: types_1.AnyType.create() }, 0 /* None */);
+            const flowNode = AnalyzerNodeInfo.getFlowNode(node);
+            if (flowNode && (flowNode.flags & codeFlowTypes_1.FlowFlags.WildcardImport) !== 0) {
+                const wildcardFlowNode = flowNode;
+                wildcardFlowNode.names.forEach((name) => {
+                    var _a, _b;
+                    const importedSymbolType = getAliasedSymbolTypeForName(node, name);
+                    if (!importedSymbolType) {
+                        return;
+                    }
+                    const symbolWithScope = lookUpSymbolRecursive(node, name, /* honorCodeFlow */ false);
+                    if (!symbolWithScope) {
+                        return;
+                    }
+                    const declaredType = (_a = getDeclaredTypeOfSymbol(symbolWithScope.symbol)) === null || _a === void 0 ? void 0 : _a.type;
+                    if (!declaredType) {
+                        return;
+                    }
+                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    if (!assignType(declaredType, importedSymbolType, diagAddendum)) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatchWildcard().format({
+                            ...printSrcDestTypes(importedSymbolType, declaredType),
+                            name,
+                        }) + diagAddendum.getString(), node, (_b = node.wildcardToken) !== null && _b !== void 0 ? _b : node);
+                    }
+                });
+            }
         }
-        // Is there a cached module type associated with this node? If so, use
-        // it instead of the type we just created.
-        const cachedModuleType = readTypeCache(node, 0 /* None */);
-        if (cachedModuleType && (0, types_1.isModule)(cachedModuleType) && symbolType) {
-            if ((0, types_1.isTypeSame)(symbolType, cachedModuleType)) {
-                symbolType = cachedModuleType;
+        else {
+            // Use the first element of the name parts as the symbol.
+            const symbolNameNode = node.module.nameParts[0];
+            // Look up the symbol to find the alias declaration.
+            let symbolType = getAliasedSymbolTypeForName(node, symbolNameNode.value);
+            if (!symbolType) {
+                return;
             }
+            // Is there a cached module type associated with this node? If so, use
+            // it instead of the type we just created.
+            const cachedModuleType = readTypeCache(node, 0 /* None */);
+            if (cachedModuleType && (0, types_1.isModule)(cachedModuleType) && symbolType) {
+                if ((0, types_1.isTypeSame)(symbolType, cachedModuleType)) {
+                    symbolType = cachedModuleType;
+                }
+            }
+            assignTypeToNameNode(symbolNameNode, symbolType, 
+            /* isIncomplete */ false, 
+            /* ignoreEmptyContainers */ false);
+            writeTypeCache(node, { type: symbolType }, 0 /* None */);
         }
-        assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForTypeAnnotationNode(node) {
         var _a;
@@ -13663,6 +13819,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     if ((0, types_1.isParamSpec)(typeArg)) {
                                         functionType.details.paramSpec = typeArg;
                                     }
+                                    else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
+                                        types_1.FunctionType.addDefaultParameters(functionType);
+                                        functionType.details.flags |=
+                                            32768 /* SkipArgsKwargsCompatibilityCheck */;
+                                    }
                                 }
                                 else {
                                     types_1.FunctionType.addParameter(functionType, {
@@ -13762,8 +13923,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let flags = 128 /* ExpectingInstantiableType */ |
             8 /* EvaluateStringLiteralAsType */ |
             131072 /* DisallowClassVar */;
-        if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId)) {
-            flags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
+        if (options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId) {
+            flags |= 4096 /* AllowTypeVarsWithoutScopeId */;
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile || (options === null || options === void 0 ? void 0 : options.allowForwardReference)) {
@@ -15650,6 +15811,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const variance = destTypeParam ? types_1.TypeVarType.getVariance(destTypeParam) : 3 /* Covariant */;
             let effectiveFlags;
             let errorSource;
+            let includeDiagAddendum = true;
             if (variance === 3 /* Covariant */) {
                 effectiveFlags = flags | 128 /* RetainLiteralsForTypeVar */;
                 errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsCovariant;
@@ -15662,6 +15824,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 effectiveFlags = flags | 1 /* EnforceInvariance */ | 128 /* RetainLiteralsForTypeVar */;
                 errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsInvariant;
+                // Omit the diagnostic addendum for the invariant case because it's obvious
+                // why two types are not the same.
+                includeDiagAddendum = false;
             }
             if (!assignType(variance === 4 /* Contravariant */ ? srcTypeArg : destTypeArg, variance === 4 /* Contravariant */ ? destTypeArg : srcTypeArg, assignmentDiag, variance === 4 /* Contravariant */ ? srcTypeVarContext : destTypeVarContext, variance === 4 /* Contravariant */ ? destTypeVarContext : srcTypeVarContext, effectiveFlags, recursionCount)) {
                 // Don't report errors with type variables in "pseudo-random"
@@ -15674,6 +15839,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 name: types_1.TypeVarType.getReadableName(destTypeParam),
                                 ...printSrcDestTypes(srcTypeArg, destTypeArg),
                             }));
+                            if (includeDiagAddendum) {
+                                childDiag.addAddendum(assignmentDiag);
+                            }
                         }
                         else {
                             diag.addAddendum(assignmentDiag);
@@ -16895,7 +17063,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
-            else {
+            else if (!srcParamDetails.paramSpec) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionTooManyParams().format({
                     expected: srcPositionalCount,
                     received: destPositionalCount,
@@ -17044,16 +17212,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // concatenated parameters must match.
         if (targetIncludesParamSpec &&
             ((_j = srcType.details.paramSpec) === null || _j === void 0 ? void 0 : _j.nameWithScope) === ((_k = destType.details.paramSpec) === null || _k === void 0 ? void 0 : _k.nameWithScope)) {
-            const srcParamCount = srcType.details.parameters.length;
-            const destParamCount = destType.details.parameters.length;
-            if (srcParamCount !== destParamCount) {
-                // If the dest has an extra position-only parameter separator appended
-                // to the end of the signature, it's OK.
-                if (srcParamCount !== destParamCount - 1 ||
-                    destType.details.parameters[destParamCount - 1].category !== 0 /* Simple */ ||
-                    !!destType.details.parameters[destParamCount - 1].name) {
-                    canAssign = false;
-                }
+            if (srcParamDetails.params.length !== destParamDetails.params.length) {
+                canAssign = false;
             }
         }
         const effectiveSrcTypeVarContext = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? srcTypeVarContext : destTypeVarContext;
@@ -17245,6 +17405,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return types_1.ClassType.cloneForSpecialization(assignedType, newTypeArgs, /* isTypeArgumentExplicit */ true);
             }
         }
+        // If the declared and assigned types are the same generic type but the assigned type
+        // contains one or more unknowns, use the declared type instead.
+        if (types_1.ClassType.isSameGenericClass(declaredType, assignedType)) {
+            if ((0, typeUtils_1.containsAnyRecursive)(assignedType) && !(0, typeUtils_1.containsAnyRecursive)(declaredType)) {
+                return declaredType;
+            }
+        }
         return undefined;
     }
     // When a value is assigned to a variable with a declared type,
@@ -17257,29 +17424,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return declaredSubtype;
                 }
                 if (assignType(declaredSubtype, assignedSubtype)) {
-                    // If the source is generic and has unspecified type arguments,
-                    // see if we can determine them based on the declared type.
-                    if ((0, types_1.isInstantiableClass)(declaredSubtype) && (0, types_1.isInstantiableClass)(assignedSubtype)) {
+                    // If the assigned subtype is Any, stick with the declared type.
+                    if ((0, types_1.isAny)(assignedSubtype)) {
+                        return declaredSubtype;
+                    }
+                    if ((0, types_1.isClass)(declaredSubtype) &&
+                        (0, types_1.isClass)(assignedSubtype) &&
+                        types_1.TypeBase.isInstance(declaredSubtype) === types_1.TypeBase.isInstance(assignedSubtype)) {
                         const result = replaceTypeArgsWithAny(node, declaredSubtype, assignedSubtype);
                         if (result) {
                             assignedSubtype = result;
                         }
+                        return assignedSubtype;
                     }
-                    else if ((0, types_1.isClassInstance)(declaredSubtype) && (0, types_1.isClassInstance)(assignedSubtype)) {
-                        const result = replaceTypeArgsWithAny(node, types_1.ClassType.cloneAsInstantiable(declaredSubtype), types_1.ClassType.cloneAsInstantiable(assignedSubtype));
-                        if (result) {
-                            assignedSubtype = types_1.ClassType.cloneAsInstance(result);
-                        }
-                    }
-                    else if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype)) {
+                    if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype)) {
                         // If the source is an unsolved TypeVar but the declared type is concrete,
                         // use the concrete type.
                         return declaredSubtype;
                     }
-                    // If the assigned subtype is Any, stick with the declared type.
-                    if ((0, types_1.isAny)(assignedSubtype)) {
-                        return declaredSubtype;
-                    }
                     // If the declared type doesn't contain any `Any` but the assigned
                     // type does, stick with the declared type.
                     if ((0, typeUtils_1.containsAnyRecursive)(assignedSubtype) && !(0, typeUtils_1.containsAnyRecursive)(declaredSubtype)) {
@@ -17347,28 +17509,42 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // must all match and be in the correct order. It is OK if the base method
         // has additional overloads that are not present in the override.
         let previousMatchIndex = -1;
-        let overrideOverloadIndex = 0;
         const baseOverloads = types_1.OverloadedFunctionType.getOverloads(baseMethod);
         for (const overrideOverload of types_1.OverloadedFunctionType.getOverloads(overrideMethod)) {
-            const matchIndex = baseOverloads.findIndex((baseOverload) => {
+            let possibleMatchIndex;
+            let matchIndex = baseOverloads.findIndex((baseOverload, index) => {
                 // If the override isn't applicable for this base class, skip the check.
                 if (baseClass && !isOverrideMethodApplicable(baseOverload, baseClass)) {
                     return false;
                 }
-                return validateOverrideMethodInternal(baseOverload, overrideOverload, 
+                const isCompatible = validateOverrideMethodInternal(baseOverload, overrideOverload, 
                 /* diag */ undefined, enforceParamNames, 
                 /* exemptSelfClsParam */ false);
+                // If the override is compatible but the match is one that is below the previous
+                // matched index, keep looking for additional matches. Record the fact that
+                // we found at least one match.
+                if (isCompatible && index <= previousMatchIndex && possibleMatchIndex === undefined) {
+                    possibleMatchIndex = index;
+                    return false;
+                }
+                return isCompatible;
             });
+            if (matchIndex < 0 && possibleMatchIndex !== undefined) {
+                matchIndex = possibleMatchIndex;
+            }
             if (matchIndex < 0) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex + 1 }));
-                return false;
+                continue;
             }
             if (matchIndex < previousMatchIndex) {
                 diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadOrder());
                 return false;
             }
             previousMatchIndex = matchIndex;
-            overrideOverloadIndex++;
+        }
+        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;
         }
         return true;
     }
@@ -17638,9 +17814,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Verify that one or the other method doesn't contain a ParamSpec.
-        if (baseMethod.details.paramSpec && !overrideMethod.details.paramSpec) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecMissingInOverride());
-            canOverride = false;
+        if (baseParamDetails.paramSpec && !overrideParamDetails.paramSpec) {
+            // If the override uses an `*args: Any, **kwargs: Any` signature, we
+            // will allow this as an acceptable overload for a `*args: P.args, **kwargs: P.kwargs`.
+            const overrideHasArgsKwargs = overrideParamDetails.argsIndex !== undefined &&
+                (0, types_1.isAnyOrUnknown)(overrideParamDetails.params[overrideParamDetails.argsIndex].type) &&
+                overrideParamDetails.kwargsIndex !== undefined &&
+                (0, types_1.isAnyOrUnknown)(overrideParamDetails.params[overrideParamDetails.kwargsIndex].type);
+            if (!overrideHasArgsKwargs) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecMissingInOverride());
+                canOverride = false;
+            }
         }
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);