@zzzen/pyright-internal 1.2.0-dev.20240310 → 1.2.0-dev.20240317

package/dist/analyzer/typeEvaluator.js

@@ -1342,6 +1342,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return { type: types_1.UnknownType.create() };
         }
+        // If this is an unspecialized generic class, specialize it using the default
+        // values for its type parameters.
+        if ((0, types_1.isInstantiableClass)(objectType) &&
+            !objectType.includeSubclasses &&
+            objectType.details.typeParameters.length > 0) {
+            // Skip this if we're suppressing the use of attribute access override,
+            // such as with dundered methods (like __call__).
+            if ((flags & 512 /* MemberAccessFlags.SkipAttributeAccessOverride */) === 0) {
+                objectType = (0, typeUtils_1.specializeWithDefaultTypeArgs)(objectType);
+            }
+        }
         // Determine the class that was used to instantiate the objectType.
         // If the objectType is a class itself, then the class used to instantiate
         // it is the metaclass.
@@ -1827,8 +1838,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else {
                     const iterReturnTypeDiag = new diagnostic_1.DiagnosticAddendum();
-                    const returnType = mapSubtypesExpandTypeVars(iterReturnType, 
-                    /* conditionFilter */ undefined, (subtype) => {
+                    const returnType = mapSubtypesExpandTypeVars(iterReturnType, /* options */ undefined, (subtype) => {
                         if ((0, types_1.isAnyOrUnknown)(subtype)) {
                             return subtype;
                         }
@@ -2545,7 +2555,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return types_1.AnyType.create();
                 }
-                return subtype;
+                // Fall back to "*tuple[object, ...]".
+                return makeTupleObject([{ type: objectType !== null && objectType !== void 0 ? objectType : types_1.UnknownType.create(), isUnbounded: true }], 
+                /* isUnpacked */ true);
             }
             if ((0, types_1.isTypeVar)(subtype)) {
                 // If this is a recursive type alias placeholder
@@ -2591,16 +2603,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // its bound type and a constrained TypeVar is expanded to its individual
     // constrained types). If conditionFilter is specified, conditions that
     // do not match will be ignored.
-    function mapSubtypesExpandTypeVars(type, conditionFilter, callback, sortSubtypes = false, recursionCount = 0) {
+    function mapSubtypesExpandTypeVars(type, options, callback, recursionCount = 0) {
         const newSubtypes = [];
         let typeChanged = false;
         function expandSubtype(unexpandedType, isLastSubtype) {
             let expandedType = (0, types_1.isUnion)(unexpandedType) ? unexpandedType : makeTopLevelTypeVarsConcrete(unexpandedType);
             expandedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedType);
+            if (options === null || options === void 0 ? void 0 : options.expandCallback) {
+                expandedType = options.expandCallback(expandedType);
+            }
             (0, typeUtils_1.doForEachSubtype)(expandedType, (subtype, index, allSubtypes) => {
                 var _a;
-                if (conditionFilter) {
-                    const filteredType = applyConditionFilterToType(subtype, conditionFilter, recursionCount);
+                if (options === null || options === void 0 ? void 0 : options.conditionFilter) {
+                    const filteredType = applyConditionFilterToType(subtype, options.conditionFilter, recursionCount);
                     if (!filteredType) {
                         return undefined;
                     }
@@ -2625,10 +2640,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 return undefined;
-            }, sortSubtypes);
+            }, options === null || options === void 0 ? void 0 : options.sortSubtypes);
         }
         if ((0, types_1.isUnion)(type)) {
-            const subtypes = sortSubtypes ? (0, typeUtils_1.sortTypes)(type.subtypes) : type.subtypes;
+            const subtypes = (options === null || options === void 0 ? void 0 : options.sortSubtypes) ? (0, typeUtils_1.sortTypes)(type.subtypes) : type.subtypes;
             subtypes.forEach((subtype, index) => {
                 expandSubtype(subtype, index === type.subtypes.length - 1);
             });
@@ -2669,10 +2684,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (variance !== 3 /* Variance.Covariant */) {
                     return typeArg;
                 }
-                const filteredTypeArg = mapSubtypesExpandTypeVars(typeArg, conditionFilter, (expandedSubtype) => {
+                const filteredTypeArg = mapSubtypesExpandTypeVars(typeArg, { conditionFilter }, (expandedSubtype) => {
                     return expandedSubtype;
-                }, 
-                /* sortSubtypes */ undefined, recursionCount);
+                }, recursionCount);
                 if (filteredTypeArg !== typeArg) {
                     typeWasTransformed = true;
                 }
@@ -3288,11 +3302,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const defaultTypeArgs = [];
             const typeVarContext = new typeVarContext_1.TypeVarContext(type.typeAliasInfo.typeVarScopeId);
             type.typeAliasInfo.typeParameters.forEach((param) => {
-                if (!param.details.defaultType) {
+                if (!param.details.isDefaultExplicit) {
                     reportMissingTypeArguments = true;
                 }
                 let defaultType;
-                if (param.details.defaultType || param.details.isParamSpec) {
+                if (param.details.isDefaultExplicit || param.details.isParamSpec) {
                     defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
                 }
                 else if (param.details.isVariadic && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
@@ -4386,7 +4400,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // known to have symmetric __getitem__ and __setitem__ methods (i.e. the value
             // passed to __setitem__ is the same type as the value returned by __getitem__).
             let baseTypeSupportsIndexNarrowing = !(0, types_1.isAny)(baseTypeResult.type);
-            mapSubtypesExpandTypeVars(baseTypeResult.type, /* conditionFilter */ undefined, (subtype) => {
+            mapSubtypesExpandTypeVars(baseTypeResult.type, /* options */ undefined, (subtype) => {
                 if (!(0, types_1.isClassInstance)(subtype) ||
                     !(types_1.ClassType.isBuiltIn(subtype) || types_1.ClassType.isTypedDictClass(subtype))) {
                     baseTypeSupportsIndexNarrowing = false;
@@ -4460,8 +4474,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // param somewhere in the list?
         if (variadicIndex >= 0) {
             const variadicTypeVar = typeParameters[variadicIndex];
+            // If the type param list ends with a ParamSpec with a default value,
+            // we can ignore it for purposes of finding type args that map to the
+            // TypeVarTuple.
+            let typeParamCount = typeParameters.length;
+            while (typeParamCount > 0) {
+                const lastTypeParam = typeParameters[typeParamCount - 1];
+                if (!lastTypeParam.details.isParamSpec || !lastTypeParam.details.isDefaultExplicit) {
+                    break;
+                }
+                typeParamCount--;
+            }
             if (variadicIndex < typeArgs.length) {
-                const variadicTypeResults = typeArgs.slice(variadicIndex, variadicIndex + 1 + typeArgs.length - typeParameters.length);
+                // If there are typeArg lists at the end, these should map to ParamSpecs rather
+                // than the TypeVarTuple, so exclude them.
+                let variadicEndIndex = variadicIndex + 1 + typeArgs.length - typeParamCount;
+                while (variadicEndIndex > variadicIndex) {
+                    if (!typeArgs[variadicEndIndex - 1].typeList) {
+                        break;
+                    }
+                    variadicEndIndex--;
+                }
+                const variadicTypeResults = typeArgs.slice(variadicIndex, variadicEndIndex);
                 // If the type args consist of a lone variadic type variable, don't wrap it in a tuple.
                 if (variadicTypeResults.length === 1 && (0, types_1.isVariadicTypeVar)(variadicTypeResults[0].type)) {
                     validateVariadicTypeVarIsUnpacked(variadicTypeResults[0].type, variadicTypeResults[0].node);
@@ -4492,11 +4526,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeArgs = [
                         ...typeArgs.slice(0, variadicIndex),
                         { node: typeArgs[variadicIndex].node, type: tupleObject },
-                        ...typeArgs.slice(variadicIndex + 1 + typeArgs.length - typeParameters.length, typeArgs.length),
+                        ...typeArgs.slice(variadicEndIndex, typeArgs.length),
                     ];
                 }
             }
-            else if (!variadicTypeVar.details.defaultType) {
+            else if (!variadicTypeVar.details.isDefaultExplicit) {
                 // Add an empty tuple that maps to the TypeVarTuple type parameter.
                 typeArgs.push({
                     node: errorNode,
@@ -4551,7 +4585,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         let minTypeArgCount = typeParameters.length;
-        const firstDefaultParamIndex = typeParameters.findIndex((param) => !!param.details.defaultType);
+        const firstDefaultParamIndex = typeParameters.findIndex((param) => !!param.details.isDefaultExplicit);
         if (firstDefaultParamIndex >= 0) {
             minTypeArgCount = firstDefaultParamIndex;
         }
@@ -4645,7 +4679,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (index < typeArgs.length) {
                     typeArgType = (0, typeUtils_1.convertToInstance)(typeArgs[index].type);
                 }
-                else if (param.details.defaultType) {
+                else if (param.details.isDefaultExplicit) {
                     typeArgType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
                 }
                 else {
@@ -4717,7 +4751,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isNotRequired = false;
         let isReadOnly = false;
         const type = mapSubtypesExpandTypeVars(baseTypeResult.type, 
-        /* conditionFilter */ undefined, (concreteSubtype, unexpandedSubtype) => {
+        /* options */ undefined, (concreteSubtype, unexpandedSubtype) => {
             var _a;
             const selfType = (0, types_1.isTypeVar)(unexpandedSubtype) ? unexpandedSubtype : undefined;
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
@@ -6437,8 +6471,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
-        let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
-        /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype, isLastIteration) => {
+        let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, { sortSubtypes: true }, (expandedSubtype, unexpandedSubtype, isLastIteration) => {
             return useSpeculativeMode(isLastIteration ? undefined : errorNode, () => {
                 const callResult = validateCallArgumentsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
                 if (callResult.argumentErrors) {
@@ -6455,8 +6488,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }, {
                 allowDiagnostics: true,
             });
-        }, 
-        /* sortSubtypes */ true);
+        });
         // If we ended up with a "Never" type because all code paths returned
         // undefined due to argument errors, transform the result into an Unknown
         // to avoid subsequent false positives.
@@ -8419,7 +8451,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // if appropriate. This doesn't properly handle non-top-level constrained
         // type variables.
         if (options.conditionFilter) {
-            argType = mapSubtypesExpandTypeVars(argType, options.conditionFilter, (expandedSubtype) => {
+            argType = mapSubtypesExpandTypeVars(argType, { conditionFilter: options.conditionFilter }, (expandedSubtype) => {
                 return expandedSubtype;
             });
         }
@@ -8661,6 +8693,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         allowTypeVarsWithoutScopeId: true,
                     }).type;
                     typeVar.details.defaultType = (0, typeUtils_1.convertToInstance)(argType);
+                    typeVar.details.isDefaultExplicit = true;
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
                         fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
@@ -8694,23 +8727,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // If a default is provided, make sure it is compatible with the bound
         // or constraint.
-        if (typeVar.details.defaultType && defaultValueNode) {
-            const typeVarContext = new typeVarContext_1.TypeVarContext(types_1.WildcardTypeVarScopeId);
-            const concreteDefaultType = makeTopLevelTypeVarsConcrete((0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, {
-                unknownIfNotFound: true,
-            }));
-            if (typeVar.details.boundType) {
-                if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultBoundMismatch(), defaultValueNode);
-                }
+        if (typeVar.details.isDefaultExplicit && defaultValueNode) {
+            verifyTypeVarDefaultIsCompatible(typeVar, defaultValueNode);
+        }
+        return typeVar;
+    }
+    function verifyTypeVarDefaultIsCompatible(typeVar, defaultValueNode) {
+        (0, debug_1.assert)(typeVar.details.isDefaultExplicit);
+        const typeVarContext = new typeVarContext_1.TypeVarContext(types_1.WildcardTypeVarScopeId);
+        const concreteDefaultType = makeTopLevelTypeVarsConcrete((0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, {
+            unknownIfNotFound: true,
+        }));
+        if (typeVar.details.boundType) {
+            if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultBoundMismatch(), defaultValueNode);
             }
-            else if (typeVar.details.constraints.length > 0) {
-                if (!typeVar.details.constraints.some((constraint) => (0, types_1.isTypeSame)(constraint, concreteDefaultType))) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultConstraintMismatch(), defaultValueNode);
+        }
+        else if (typeVar.details.constraints.length > 0) {
+            let isConstraintCompatible = true;
+            // If the default type is a constrained TypeVar, make sure all of its constraints
+            // are also constraints in typeVar. If the default type is not a constrained TypeVar,
+            // use its concrete type to compare against the constraints.
+            if ((0, types_1.isTypeVar)(typeVar.details.defaultType) && typeVar.details.defaultType.details.constraints.length > 0) {
+                for (const constraint of typeVar.details.defaultType.details.constraints) {
+                    if (!typeVar.details.constraints.some((c) => (0, types_1.isTypeSame)(c, constraint))) {
+                        isConstraintCompatible = false;
+                    }
                 }
             }
+            else if (!typeVar.details.constraints.some((constraint) => (0, types_1.isTypeSame)(constraint, concreteDefaultType, { ignoreConditions: true }))) {
+                isConstraintCompatible = false;
+            }
+            if (!isConstraintCompatible) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultConstraintMismatch(), defaultValueNode);
+            }
         }
-        return typeVar;
     }
     function createTypeVarTupleType(errorNode, classType, argList) {
         var _a, _b;
@@ -8728,6 +8779,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false), types_1.ClassType.cloneAsInstance(classType));
         typeVar.details.isVariadic = true;
+        typeVar.details.defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
             const paramNameNode = argList[i].name;
@@ -8736,7 +8788,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramName === 'default') {
                     const expr = argList[i].valueExpression;
                     if (expr) {
-                        typeVar.details.defaultType = getTypeVarTupleDefaultType(expr);
+                        const defaultType = getTypeVarTupleDefaultType(expr);
+                        if (defaultType) {
+                            typeVar.details.defaultType = defaultType;
+                            typeVar.details.isDefaultExplicit = true;
+                        }
                     }
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
@@ -8782,6 +8838,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addError(localize_1.LocMessage.paramSpecFirstArg(), firstArg.valueExpression || errorNode);
         }
         const paramSpec = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true), types_1.ClassType.cloneAsInstance(classType));
+        paramSpec.details.defaultType = (0, typeUtils_1.getUnknownTypeForParamSpec)();
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
             const paramNameNode = argList[i].name;
@@ -8790,7 +8847,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramName === 'default') {
                     const expr = argList[i].valueExpression;
                     if (expr) {
-                        paramSpec.details.defaultType = getParamSpecDefaultType(expr);
+                        const defaultType = getParamSpecDefaultType(expr);
+                        if (defaultType) {
+                            paramSpec.details.defaultType = defaultType;
+                            paramSpec.details.isDefaultExplicit = true;
+                        }
                     }
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
@@ -9582,8 +9643,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 verifySetEntryOrDictKeyIsHashable(entry, entryTypeResult.type, /* isDictKey */ false);
             }
         });
-        const isTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
-            types_1.ClassType.isBuiltIn(inferenceContext.expectedType, builtInClassName);
+        let isTypeInvariant = false;
+        if ((0, types_1.isClassInstance)(inferenceContext.expectedType)) {
+            inferTypeParameterVarianceForClass(inferenceContext.expectedType);
+            if (inferenceContext.expectedType.details.typeParameters.some((t) => types_1.TypeVarType.getVariance(t) === 2 /* Variance.Invariant */)) {
+                isTypeInvariant = true;
+            }
+        }
         const specializedEntryType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedEntryType), entryTypes, !isTypeInvariant);
         if (!specializedEntryType) {
             return { type: types_1.UnknownType.create(), isIncomplete, typeErrors: true, expectedTypeDiagAddendum };
@@ -9624,7 +9690,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let entryTypes = [];
         node.entries.forEach((entry, index) => {
             let entryTypeResult;
-            if (entry.nodeType === 32 /* ParseNodeType.ListComprehension */) {
+            if (entry.nodeType === 32 /* ParseNodeType.ListComprehension */ && !entry.isGenerator) {
                 entryTypeResult = getElementTypeFromListComprehension(entry);
             }
             else {
@@ -9684,7 +9750,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.unhashableType().format({ type: printType(type) }));
             const message = isDictKey ? localize_1.LocMessage.unhashableDictKey() : localize_1.LocMessage.unhashableSetEntry();
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), entry);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnhashable, message + diag.getString(), entry);
         }
     }
     function inferTypeArgFromExpectedEntryType(inferenceContext, entryTypes, isNarrowable) {
@@ -10902,6 +10968,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return (0, typeUtils_1.convertToInstance)(typeVar);
         });
+        // See if the type alias includes a TypeVarTuple followed by a TypeVar
+        // with a default value. This isn't allowed.
+        const firstTypeVarTupleIndex = typeParameters.findIndex((typeVar) => (0, types_1.isVariadicTypeVar)(typeVar));
+        if (firstTypeVarTupleIndex >= 0) {
+            const typeVarWithDefaultIndex = typeParameters.findIndex((typeVar, index) => index > firstTypeVarTupleIndex && !typeVar.details.isParamSpec && typeVar.details.isDefaultExplicit);
+            if (typeVarWithDefaultIndex >= 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithDefaultFollowsVariadic().format({
+                    typeVarName: typeParameters[typeVarWithDefaultIndex].details.name,
+                    variadicName: typeParameters[firstTypeVarTupleIndex].details.name,
+                }), typeParamNodes ? typeParamNodes[typeVarWithDefaultIndex].name : name);
+            }
+        }
         const typeAliasScopeId = ParseTreeUtils.getScopeIdForNode(name);
         // Validate the default types for all type parameters.
         typeParameters.forEach((typeParam, index) => {
@@ -11310,6 +11388,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         aliasType = transformTypeForTypeAlias(aliasType, nameNode, nameNode, isPep695Syntax, 
         /* isPep695TypeVarType */ true, typeParameters, typeParamNodes);
+        // See if the type alias relies on itself in a way that cannot be resolved.
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
                 name: nameNode.value,
@@ -11659,12 +11738,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 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));
+            const variadics = typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
             if (variadics.length > 1) {
-                addError(localize_1.LocMessage.variadicTypeParamTooManyClass().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.variadicTypeParamTooManyClass().format({
                     names: variadics.map((v) => `"${v.details.name}"`).join(', '),
                 }), node.name, textRange_1.TextRange.combine(node.arguments) || node.name);
             }
+            else if (variadics.length > 0) {
+                // Make sure a TypeVar with a default doesn't come after a variadic type parameter.
+                const firstVariadicIndex = classType.details.typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
+                const typeVarWithDefaultIndex = classType.details.typeParameters.findIndex((param, index) => index > firstVariadicIndex && !param.details.isParamSpec && param.details.isDefaultExplicit);
+                if (typeVarWithDefaultIndex >= 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithDefaultFollowsVariadic().format({
+                        typeVarName: typeParameters[typeVarWithDefaultIndex].details.name,
+                        variadicName: typeParameters[firstVariadicIndex].details.name,
+                    }), node.typeParameters ? node.typeParameters.parameters[typeVarWithDefaultIndex].name : node.name);
+                }
+            }
             // Validate the default types for all type parameters.
             classType.details.typeParameters.forEach((typeParam, index) => {
                 var _a;
@@ -11676,7 +11766,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 validateTypeParameterDefault(bestErrorNode, typeParam, classType.details.typeParameters.slice(0, index), classType.details.typeVarScopeId);
             });
             if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
-                addError(localize_1.LocMessage.methodOrdering(), node.name);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodOrdering(), node.name);
             }
             // The scope for this class becomes the "fields" for the corresponding type.
             const innerScope = ScopeUtils.getScopeForNode(node.suite);
@@ -11892,10 +11982,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // parameters and updates the scope of the type parameter referred to in the
     // default type expression.
     function validateTypeParameterDefault(errorNode, typeParam, otherLiveTypeParams, scopeId) {
-        if (!typeParam.details.defaultType &&
+        if (!typeParam.details.isDefaultExplicit &&
             !typeParam.details.isSynthesized &&
             !typeParam.details.isSynthesizedSelf) {
-            const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType && param.scopeId === scopeId);
+            const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.isDefaultExplicit && param.scopeId === scopeId);
             if (typeVarWithDefault) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithoutDefault().format({
                     name: typeParam.details.name,
@@ -14110,7 +14200,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const variadicTypeParamIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         if (typeArgs) {
             let minTypeArgCount = typeParameters.length;
-            const firstDefaultParamIndex = typeParameters.findIndex((param) => !!param.details.defaultType);
+            const firstDefaultParamIndex = typeParameters.findIndex((param) => !!param.details.isDefaultExplicit);
             if (firstDefaultParamIndex >= 0) {
                 minTypeArgCount = firstDefaultParamIndex;
             }
@@ -14965,35 +15055,43 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        if (node.defaultExpression) {
-            if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
-                typeVar.details.defaultType = getParamSpecDefaultType(node.defaultExpression);
+        if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
+            const defaultType = node.defaultExpression ? getParamSpecDefaultType(node.defaultExpression) : undefined;
+            if (defaultType) {
+                typeVar.details.defaultType = defaultType;
+                typeVar.details.isDefaultExplicit = true;
             }
-            else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
-                typeVar.details.defaultType = getTypeVarTupleDefaultType(node.defaultExpression);
+            else {
+                typeVar.details.defaultType = (0, typeUtils_1.getUnknownTypeForParamSpec)();
+            }
+        }
+        else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
+            const defaultType = node.defaultExpression ? getTypeVarTupleDefaultType(node.defaultExpression) : undefined;
+            if (defaultType) {
+                typeVar.details.defaultType = defaultType;
+                typeVar.details.isDefaultExplicit = true;
             }
             else {
-                typeVar.details.defaultType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.defaultExpression).type);
+                typeVar.details.defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
             }
         }
-        // If a default is provided, make sure it is compatible with the bound
-        // or constraint.
-        if (typeVar.details.defaultType && node.defaultExpression) {
-            const typeVarContext = new typeVarContext_1.TypeVarContext(types_1.WildcardTypeVarScopeId);
-            const concreteDefaultType = (0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, {
-                unknownIfNotFound: true,
-            });
-            if (typeVar.details.boundType) {
-                if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultBoundMismatch(), node.defaultExpression);
-                }
+        else {
+            const defaultType = node.defaultExpression
+                ? (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.defaultExpression).type)
+                : undefined;
+            if (defaultType) {
+                typeVar.details.defaultType = defaultType;
+                typeVar.details.isDefaultExplicit = true;
             }
-            else if (typeVar.details.constraints.length > 0) {
-                if (!typeVar.details.constraints.some((constraint) => (0, types_1.isTypeSame)(constraint, concreteDefaultType))) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultConstraintMismatch(), node.defaultExpression);
-                }
+            else {
+                typeVar.details.defaultType = types_1.UnknownType.create();
             }
         }
+        // If a default is provided, make sure it is compatible with the bound
+        // or constraint.
+        if (typeVar.details.isDefaultExplicit && node.defaultExpression) {
+            verifyTypeVarDefaultIsCompatible(typeVar, node.defaultExpression);
+        }
         // Associate the type variable with the owning scope.
         const scopeNode = ParseTreeUtils.getTypeVarScopeNode(node);
         if (scopeNode) {
@@ -15354,7 +15452,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const resolvedDecl = (_a = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
                 allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
             })) !== null && _a !== void 0 ? _a : decl;
-            if (!isPossibleTypeAliasDeclaration(resolvedDecl)) {
+            if (!isPossibleTypeAliasDeclaration(resolvedDecl) && !isExplicitTypeAliasDeclaration(resolvedDecl)) {
                 includesIllegalTypeAliasDecl = true;
             }
             if (resolvedDecl.type === 1 /* DeclarationType.Variable */) {
@@ -17854,7 +17952,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (srcStartOfNamed >= 0) {
                 srcParamDetails.params.forEach((srcParamInfo, index) => {
                     if (index >= srcStartOfNamed) {
-                        if (srcParamInfo.param.name && srcParamInfo.param.category === 0 /* ParameterCategory.Simple */) {
+                        if (srcParamInfo.param.name &&
+                            srcParamInfo.param.category === 0 /* ParameterCategory.Simple */ &&
+                            srcParamInfo.source !== parameterUtils_1.ParameterSource.PositionOnly) {
                             const destParamInfo = destParamMap.get(srcParamInfo.param.name);
                             const paramDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                             const srcParamType = srcParamInfo.type;
@@ -18469,6 +18569,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
+            // Check for positional (named) parameters in the base method that
+            // do not exist in the override.
+            if (enforceParamNames && overrideParamDetails.kwargsIndex === undefined) {
+                for (let i = positionalParamCount; i < baseParamDetails.positionParamCount; i++) {
+                    const baseParam = baseParamDetails.params[i];
+                    if (baseParam.source === parameterUtils_1.ParameterSource.PositionOrKeyword &&
+                        baseParam.param.category === 0 /* ParameterCategory.Simple */) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
+                            index: i + 1,
+                            baseName: baseParam.param.name || '*',
+                        }));
+                        canOverride = false;
+                    }
+                }
+            }
             // Check for a *args match.
             if (baseParamDetails.argsIndex !== undefined) {
                 if (overrideParamDetails.argsIndex === undefined) {