@zzzen/pyright-internal 1.2.0-dev.20240307 → 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;
                         }
@@ -2034,12 +2044,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Although isFlowNodeReachable indicates that the node is reachable, it
     // may not be reachable if we apply "never narrowing".
     function isFlowNodeReachableUsingNeverNarrowing(node, flowNode) {
-        const analyzer = getCodeFlowAnalyzerForNode(node.id);
+        const analyzer = getCodeFlowAnalyzerForNode(node.id, /* typeAtStart */ undefined);
         if (checkCodeFlowTooComplex(node)) {
             return true;
         }
         const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, /* reference */ undefined, {
-            typeAtStart: types_1.UnboundType.create(),
+            typeAtStart: { type: types_1.UnboundType.create() },
         });
         return codeFlowResult.type !== undefined && !(0, types_1.isNever)(codeFlowResult.type);
     }
@@ -2221,12 +2231,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const varDecl = declarations.find((decl) => decl.type === 1 /* DeclarationType.Variable */);
+        const varDeclIndex = declarations.findIndex((decl) => decl.type === 1 /* DeclarationType.Variable */);
+        const varDecl = varDeclIndex >= 0 ? declarations[varDeclIndex] : undefined;
+        // Are there any non-var decls before the var decl?
+        const nonVarDecl = declarations.find((decl, index) => varDeclIndex < index && decl.type !== 1 /* DeclarationType.Variable */);
         if (varDecl && varDecl.type === 1 /* DeclarationType.Variable */) {
             if (varDecl.isConstant) {
                 // A constant variable can be assigned only once. If this
                 // isn't the first assignment, generate an error.
-                if (nameNode !== (0, declarationUtils_1.getNameNodeForDeclaration)(declarations[0])) {
+                if (nameNode !== (0, declarationUtils_1.getNameNodeForDeclaration)(declarations[0]) || !!nonVarDecl) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportConstantRedefinition, localize_1.LocMessage.constantRedefinition().format({ name: nameValue }), nameNode);
                 }
             }
@@ -2542,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
@@ -2588,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;
                     }
@@ -2622,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);
             });
@@ -2666,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;
                 }
@@ -2970,6 +2987,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // type. If it's declared inside our execution scope, it generally starts
                     // as unbound at the start of the code flow.
                     let typeAtStart = effectiveType;
+                    let isTypeAtStartIncomplete = false;
                     if (!symbolWithScope.isBeyondExecutionScope && symbol.isInitiallyUnbound()) {
                         typeAtStart = types_1.UnboundType.create();
                         // Is this a module-level scope? If so, see if it's an alias of a builtin.
@@ -2982,9 +3000,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         }
                     }
+                    if (symbolWithScope.isBeyondExecutionScope) {
+                        const outerScopeTypeResult = getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType);
+                        if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.type) {
+                            type = outerScopeTypeResult.type;
+                            typeAtStart = type;
+                            isTypeAtStartIncomplete = !!outerScopeTypeResult.isIncomplete;
+                        }
+                    }
                     const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
                         targetSymbolId: symbol.id,
-                        typeAtStart,
+                        typeAtStart: { type: typeAtStart, isIncomplete: isTypeAtStartIncomplete },
                         skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
                     });
                     if (codeFlowTypeResult.type) {
@@ -2993,15 +3019,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (codeFlowTypeResult.isIncomplete) {
                         isIncomplete = true;
                     }
-                    if (!codeFlowTypeResult.type && symbolWithScope.isBeyondExecutionScope) {
-                        const outerScopeTypeResult = getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType);
-                        if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.type) {
-                            type = outerScopeTypeResult.type;
-                        }
-                        if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.isIncomplete) {
-                            isIncomplete = true;
-                        }
-                    }
                 }
                 // Detect, report, and fill in missing type arguments if appropriate.
                 type = reportMissingTypeArguments(node, type, flags);
@@ -3139,7 +3156,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         return getFlowTypeOfReference(node, innerScopeNode, {
                             targetSymbolId: symbolWithScope.symbol.id,
-                            typeAtStart,
+                            typeAtStart: { type: typeAtStart },
                         });
                     }
                 }
@@ -3285,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)) {
@@ -3466,8 +3483,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // See if we can refine the type based on code flow analysis.
             const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
                 targetSymbolId: symbol_1.indeterminateSymbolId,
-                typeAtStart,
-                isTypeAtStartIncomplete,
+                typeAtStart: { type: typeAtStart, isIncomplete: isTypeAtStartIncomplete },
                 skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
             });
             if (codeFlowTypeResult.type) {
@@ -4384,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;
@@ -4397,8 +4413,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // See if we can refine the type based on code flow analysis.
                 const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
                     targetSymbolId: symbol_1.indeterminateSymbolId,
-                    typeAtStart: indexTypeResult.type,
-                    isTypeAtStartIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
+                    typeAtStart: {
+                        type: indexTypeResult.type,
+                        isIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
+                    },
                     skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
                 });
                 if (codeFlowTypeResult.type) {
@@ -4456,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);
@@ -4488,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,
@@ -4547,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;
         }
@@ -4641,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 {
@@ -4713,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)) {
@@ -6433,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) {
@@ -6451,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.
@@ -6704,12 +6740,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expandedCallType.details.name === 'type' && argList.length === 1) {
                     const argType = getTypeOfArgument(argList[0]).type;
                     const returnType = (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
+                        var _a;
+                        if ((0, types_1.isInstantiableClass)(subtype)) {
+                            return (_a = subtype.details.effectiveMetaclass) !== null && _a !== void 0 ? _a : types_1.AnyType.create();
+                        }
                         if ((0, types_1.isClassInstance)(subtype) ||
                             ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstance(subtype)) ||
                             (0, typeUtils_1.isNoneInstance)(subtype)) {
                             return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
                         }
-                        else if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
+                        if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
                             return types_1.FunctionType.cloneAsInstantiable(subtype);
                         }
                         return types_1.AnyType.create();
@@ -8411,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;
             });
         }
@@ -8653,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 &&
@@ -8686,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;
@@ -8720,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;
@@ -8728,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 &&
@@ -8774,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;
@@ -8782,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 &&
@@ -9574,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 };
@@ -9616,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 {
@@ -9676,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) {
@@ -10894,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) => {
@@ -11302,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,
@@ -11651,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;
@@ -11668,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);
@@ -11884,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,
@@ -13878,12 +13976,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function getCodeFlowAnalyzerForNode(nodeId) {
-        let analyzer = codeFlowAnalyzerCache.get(nodeId);
-        if (!analyzer) {
-            // Allocate a new code flow analyzer.
-            analyzer = codeFlowEngine.createCodeFlowAnalyzer();
-            codeFlowAnalyzerCache.set(nodeId, analyzer);
+    function getCodeFlowAnalyzerForNode(nodeId, typeAtStart) {
+        let entries = codeFlowAnalyzerCache.get(nodeId);
+        if (entries) {
+            const cachedEntry = entries.find((entry) => {
+                if (!typeAtStart || !entry.typeAtStart) {
+                    return !typeAtStart && !entry.typeAtStart;
+                }
+                if (!typeAtStart.isIncomplete !== !entry.typeAtStart.isIncomplete) {
+                    return false;
+                }
+                return (0, types_1.isTypeSame)(typeAtStart.type, entry.typeAtStart.type);
+            });
+            if (cachedEntry) {
+                return cachedEntry.codeFlowAnalyzer;
+            }
+        }
+        // Allocate a new code flow analyzer.
+        const analyzer = codeFlowEngine.createCodeFlowAnalyzer(typeAtStart);
+        if (entries) {
+            entries.push({ typeAtStart, codeFlowAnalyzer: analyzer });
+        }
+        else {
+            entries = [{ typeAtStart, codeFlowAnalyzer: analyzer }];
+            codeFlowAnalyzerCache.set(nodeId, entries);
         }
         return analyzer;
     }
@@ -13916,7 +14032,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             analyzer = getCodeFlowAnalyzerForReturnTypeInferenceContext();
         }
         else {
-            analyzer = getCodeFlowAnalyzerForNode(executionNode.id);
+            analyzer = getCodeFlowAnalyzerForNode(executionNode.id, options === null || options === void 0 ? void 0 : options.typeAtStart);
         }
         const flowNode = AnalyzerNodeInfo.getFlowNode(startNode !== null && startNode !== void 0 ? startNode : reference);
         if (flowNode === undefined) {
@@ -14084,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;
             }
@@ -14939,34 +15055,42 @@ 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 {
+                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 if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
-                typeVar.details.defaultType = getTypeVarTupleDefaultType(node.defaultExpression);
+            else {
+                typeVar.details.defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
+            }
+        }
+        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 {
-                typeVar.details.defaultType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.defaultExpression).type);
+                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.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 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);
-                }
-            }
+        if (typeVar.details.isDefaultExplicit && node.defaultExpression) {
+            verifyTypeVarDefaultIsCompatible(typeVar, node.defaultExpression);
         }
         // Associate the type variable with the owning scope.
         const scopeNode = ParseTreeUtils.getTypeVarScopeNode(node);
@@ -15328,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 */) {
@@ -15725,7 +15849,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const prevTypeCache = returnTypeInferenceTypeCache;
             returnTypeInferenceContextStack.push({
                 functionNode,
-                codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(),
+                codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(/* typeAtStart */ undefined),
             });
             try {
                 returnTypeInferenceTypeCache = new Map();
@@ -17828,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;
@@ -18443,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) {