@zzzen/pyright-internal 1.2.0-dev.20221016 → 1.2.0-dev.20221204

package/dist/analyzer/typeEvaluator.js

@@ -196,6 +196,9 @@ const maxEntriesToUseForInference = 64;
 // when inferring its type? We need to cut it off at some point
 // to avoid excessive computation.
 const maxDeclarationsToUseForInference = 64;
+// Maximum number of times to attempt effective type evaluation
+// of a variable that has no type declaration.
+const maxEffectiveTypeEvaluationAttempts = 16;
 // Maximum number of combinatoric union type expansions allowed
 // when resolving an overload.
 const maxOverloadUnionExpansionCount = 64;
@@ -677,9 +680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (reportExpectingTypeErrors && !typeResult.isIncomplete) {
             if (flags & 128 /* TypeVarTupleDisallowed */) {
-                if ((0, types_1.isTypeVar)(typeResult.type) &&
-                    typeResult.type.details.isVariadic &&
-                    !typeResult.type.isVariadicInUnion) {
+                if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
                     addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
                     typeResult.type = types_1.UnknownType.create();
                 }
@@ -691,6 +692,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!isEmptyVariadic) {
                     addExpectedClassDiagnostic(typeResult.type, node);
                     typeResult.type = types_1.UnknownType.create();
+                    typeResult.typeErrors = true;
                 }
             }
         }
@@ -779,8 +781,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
             }
             else {
-                const type = (_a = getTypeOfIterator(iterType, /* isAsync */ false, node)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(!!iterTypeResult.isIncomplete);
-                typeResult = { type, unpackedType: iterType, isIncomplete: iterTypeResult.isIncomplete };
+                const iteratorTypeResult = (_a = getTypeOfIterator(iterTypeResult, /* isAsync */ false, node)) !== null && _a !== void 0 ? _a : {
+                    type: types_1.UnknownType.create(!!iterTypeResult.isIncomplete),
+                    isIncomplete: iterTypeResult.isIncomplete,
+                };
+                typeResult = {
+                    type: iteratorTypeResult.type,
+                    unpackedType: iterType,
+                    isIncomplete: iteratorTypeResult.isIncomplete,
+                };
             }
         }
         return typeResult;
@@ -869,17 +878,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // the resulting formatted string is also LiteralString.
             node.expressions.forEach((expr) => {
                 const exprType = getTypeOfExpression(expr).type;
-                if (!(0, types_1.isClassInstance)(exprType)) {
+                (0, typeUtils_1.doForEachSubtype)(exprType, (exprSubtype) => {
+                    if (!(0, types_1.isClassInstance)(exprSubtype)) {
+                        isLiteralString = false;
+                        return;
+                    }
+                    if (types_1.ClassType.isBuiltIn(exprSubtype, 'LiteralString')) {
+                        return;
+                    }
+                    if (types_1.ClassType.isBuiltIn(exprSubtype, 'str') && exprSubtype.literalValue !== undefined) {
+                        return;
+                    }
                     isLiteralString = false;
-                    return;
-                }
-                if (types_1.ClassType.isBuiltIn(exprType, 'LiteralString')) {
-                    return;
-                }
-                if (types_1.ClassType.isBuiltIn(exprType, 'str') && exprType.literalValue !== undefined) {
-                    return;
-                }
-                isLiteralString = false;
+                });
             });
             if (!isBytes && isLiteralString) {
                 const literalStringType = getTypingType(node, 'LiteralString');
@@ -1092,6 +1103,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, typeUtils_1.isTupleClass)(type) && type.tupleTypeArguments) {
                     return (0, typeUtils_1.isUnboundedTupleClass)(type) || type.tupleTypeArguments.length === 0;
                 }
+                // Handle subclasses of tuple, such as NamedTuple.
+                const tupleBaseClass = type.details.mro.find((mroClass) => !(0, types_1.isClass)(mroClass) || (0, typeUtils_1.isTupleClass)(mroClass));
+                if (tupleBaseClass && (0, types_1.isClass)(tupleBaseClass) && tupleBaseClass.tupleTypeArguments) {
+                    return (0, typeUtils_1.isUnboundedTupleClass)(tupleBaseClass) || tupleBaseClass.tupleTypeArguments.length === 0;
+                }
                 // Check for Literal[False] and Literal[True].
                 if (types_1.ClassType.isBuiltIn(type, 'bool') && type.literalValue !== undefined) {
                     return type.literalValue === false;
@@ -1402,8 +1418,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 case 7 /* Class */: {
                     if (types_1.TypeBase.isInstantiable(subtype)) {
                         let methodType;
-                        // Try to get the __init__ method first because it typically has
-                        // more type information than __new__.
+                        // Try to get the `__init__` method first because it typically has more
+                        // type information than `__new__`.
                         methodType = getBoundMethod(subtype, '__init__');
                         // Is this the __init__ method provided by the object class?
                         const isObjectInit = !!methodType &&
@@ -1413,7 +1429,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // If there was no `__init__` or the only `__init__` that was found
                         // was form the `object` class, see if we can find a better `__new__`
                         // method.
-                        if (!methodType || isObjectInit || isSkipConstructor) {
+                        if (!methodType ||
+                            isObjectInit ||
+                            isSkipConstructor ||
+                            (methodType &&
+                                (0, types_1.isFunction)(methodType) &&
+                                (types_1.FunctionType.hasDefaultParameters(methodType) ||
+                                    methodType.details.parameters.length === 0))) {
                             const constructorType = getBoundMethod(subtype, '__new__', 
                             /* recursionCount */ undefined, 
                             /* treatConstructorAsClassMember */ true);
@@ -1615,14 +1637,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Validates that the type is an iterator and returns the iterated type
     // (i.e. the type returned from the '__next__' or '__anext__' method).
-    function getTypeOfIterator(type, isAsync, errorNode) {
+    function getTypeOfIterator(typeResult, isAsync, errorNode) {
         const iterMethodName = isAsync ? '__aiter__' : '__iter__';
         const nextMethodName = isAsync ? '__anext__' : '__next__';
         let isValidIterator = true;
-        type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
+        let type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(typeResult.type);
         type = makeTopLevelTypeVarsConcrete(type);
         if ((0, typeUtils_1.isOptionalType)(type)) {
-            if (errorNode) {
+            if (errorNode && !typeResult.isIncomplete) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalIterable, diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.Localizer.Diagnostic.noneNotIterable(), errorNode);
             }
             type = (0, types_1.removeNoneFromUnion)(type);
@@ -1677,7 +1699,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return subtype;
                         }
                         if ((0, types_1.isClassInstance)(subtype)) {
-                            const nextReturnType = getSpecializedReturnType(subtype, nextMethodName, [], errorNode);
+                            let nextReturnType = getSpecializedReturnType(subtype, nextMethodName, [], errorNode);
                             if (!nextReturnType) {
                                 iterReturnTypeDiag.addMessage(localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
                                     name: nextMethodName,
@@ -1685,6 +1707,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }));
                             }
                             else {
+                                // Convert any unpacked TypeVarTuples into object instances. We don't
+                                // know anything more about them.
+                                nextReturnType = (0, typeUtils_1.mapSubtypes)(nextReturnType, (returnSubtype) => {
+                                    if ((0, types_1.isTypeVar)(returnSubtype) && (0, types_1.isUnpackedVariadicTypeVar)(returnSubtype)) {
+                                        return objectType !== null && objectType !== void 0 ? objectType : types_1.UnknownType.create();
+                                    }
+                                    return returnSubtype;
+                                });
                                 if (!isAsync) {
                                     return nextReturnType;
                                 }
@@ -1704,21 +1734,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     diag.addAddendum(iterReturnTypeDiag);
                 }
             }
-            if (errorNode) {
+            if (errorNode && !typeResult.isIncomplete) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIterable().format({ type: printType(subtype) }) + diag.getString(), errorNode);
             }
             isValidIterator = false;
             return undefined;
         });
-        return isValidIterator ? iterableType : undefined;
+        return isValidIterator ? { type: iterableType, isIncomplete: typeResult.isIncomplete } : undefined;
     }
     // Validates that the type is an iterable and returns the iterable type argument.
-    function getTypeOfIterable(type, isAsync, errorNode) {
+    function getTypeOfIterable(typeResult, isAsync, errorNode) {
         const iterMethodName = isAsync ? '__aiter__' : '__iter__';
         let isValidIterable = true;
-        type = makeTopLevelTypeVarsConcrete(type);
+        let type = makeTopLevelTypeVarsConcrete(typeResult.type);
         if ((0, typeUtils_1.isOptionalType)(type)) {
-            if (errorNode) {
+            if (errorNode && !typeResult.isIncomplete) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalIterable, diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.Localizer.Diagnostic.noneNotIterable(), errorNode);
             }
             type = (0, types_1.removeNoneFromUnion)(type);
@@ -1747,7 +1777,47 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isValidIterable = false;
             return undefined;
         });
-        return isValidIterable ? iterableType : undefined;
+        return isValidIterable ? { type: iterableType, isIncomplete: typeResult.isIncomplete } : undefined;
+    }
+    function isTypeHashable(type) {
+        let isTypeHashable = true;
+        (0, typeUtils_1.doForEachSubtype)(makeTopLevelTypeVarsConcrete(type), (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype)) {
+                // Assume the class is hashable.
+                let isObjectHashable = true;
+                // Have we already computed and cached the hashability?
+                if (subtype.details.isInstanceHashable !== undefined) {
+                    isObjectHashable = subtype.details.isInstanceHashable;
+                }
+                else {
+                    const hashMember = (0, typeUtils_1.lookUpObjectMember)(subtype, '__hash__', 4 /* SkipObjectBaseClass */);
+                    if (hashMember && hashMember.isTypeDeclared) {
+                        const decls = hashMember.symbol.getTypedDeclarations();
+                        const synthesizedType = hashMember.symbol.getSynthesizedType();
+                        // Handle the case where the type is synthesized (used for
+                        // dataclasses).
+                        if (synthesizedType) {
+                            isObjectHashable = !(0, types_1.isNoneInstance)(synthesizedType);
+                        }
+                        else {
+                            // Assume that if '__hash__' is declared as a variable, it is
+                            // not hashable. If it's declared as a function, it is. We'll
+                            // skip evaluating its full type because that's not needed in
+                            // this case.
+                            if (decls.every((decl) => decl.type === 1 /* Variable */)) {
+                                isObjectHashable = false;
+                            }
+                        }
+                    }
+                    // Cache the hashability for next time.
+                    subtype.details.isInstanceHashable = isObjectHashable;
+                }
+                if (!isObjectHashable) {
+                    isTypeHashable = false;
+                }
+            }
+        });
+        return isTypeHashable;
     }
     function getTypedDictClassType() {
         return typedDictClassType;
@@ -1834,10 +1904,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, 
         /* reference */ undefined, 
         /* targetSymbolId */ undefined, 
-        /* initialType */ types_1.UnboundType.create(), {
+        /* typeAtStart */ types_1.UnboundType.create(), {
             skipNoReturnCallAnalysis: true,
         });
-        return codeFlowResult.type !== undefined;
+        return codeFlowResult.type !== undefined && !(0, types_1.isNever)(codeFlowResult.type);
     }
     // Determines whether there is a code flow path from sourceNode to sinkNode.
     function isFlowPathBetweenNodes(sourceNode, sinkNode, allowSelf = true) {
@@ -2158,6 +2228,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         type = makeTopLevelTypeVarsConcrete(type);
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            var _a, _b;
             // Is this subtype a tuple?
             const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
             if (tupleType && tupleType.tupleTypeArguments) {
@@ -2214,7 +2285,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 // The assigned expression isn't a tuple, so it had better
                 // be some iterable type.
-                const iterableType = getTypeOfIterator(subtype, /* isAsync */ false, srcExpr) || types_1.UnknownType.create();
+                const iterableType = (_b = (_a = getTypeOfIterator({ type: subtype, isIncomplete: isTypeIncomplete }, /* isAsync */ false, srcExpr)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 for (let index = 0; index < targetExpressions.length; index++) {
                     targetTypes[index].push((0, typeUtils_1.addConditionToType)(iterableType, (0, typeUtils_1.getTypeCondition)(subtype)));
                 }
@@ -2266,9 +2337,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return types_1.UnknownType.create();
                 }
             }
+            // If this is a TypeVarTuple *Ts, convert it to an unpacked tuple
+            // *tuple[*Ts].
             if ((0, types_1.isVariadicTypeVar)(subtype)) {
                 if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                    return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
+                    return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: subtype, isUnbounded: false }], 
                     /* isTypeArgumentExplicit */ true, 
                     /* isUnpackedTuple */ true));
                 }
@@ -2533,7 +2606,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (!(0, typeUtils_1.derivesFromClassRecursive)(concreteSubtype, baseExceptionType, 
                             /* ignoreUnknown */ false)) {
                                 diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
-                                    type: printType(subtype, /* expandTypeAlias */ false),
+                                    type: printType(subtype),
                                 }));
                             }
                             else {
@@ -2545,7 +2618,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 });
                                 if (callResult && callResult.argumentErrors) {
                                     diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeNotInstantiable().format({
-                                        type: printType(subtype, /* expandTypeAlias */ false),
+                                        type: printType(subtype),
                                     }));
                                 }
                             }
@@ -2554,13 +2627,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(concreteSubtype), baseExceptionType, 
                             /* ignoreUnknown */ false)) {
                                 diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
-                                    type: printType(subtype, /* expandTypeAlias */ false),
+                                    type: printType(subtype),
                                 }));
                             }
                         }
                         else {
                             diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
-                                type: printType(subtype, /* expandTypeAlias */ false),
+                                type: printType(subtype),
                             }));
                         }
                     }
@@ -2642,7 +2715,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!classMember) {
             return undefined;
         }
-        const memberType = getTypeOfMember(classMember);
+        const memberTypeResult = getTypeOfMemberInternal(classMember, objType);
+        if (!memberTypeResult) {
+            return undefined;
+        }
+        const memberType = memberTypeResult.type;
         if ((0, types_1.isAnyOrUnknown)(memberType)) {
             return memberType;
         }
@@ -2684,6 +2761,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
             }
         }
+        // Does this name refer to a PEP 695-style type parameter?
         const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
         if (typeParamSymbol) {
             symbol = typeParamSymbol;
@@ -2693,7 +2771,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             // Look for the scope that contains the value definition and
             // see if it has a declared type.
-            const symbolWithScope = lookUpSymbolRecursive(node, name, !allowForwardReferences, allowForwardReferences && (flags & 1024 /* ExpectingTypeAnnotation */) !== 0);
+            let symbolWithScope = lookUpSymbolRecursive(node, name, !allowForwardReferences, allowForwardReferences && (flags & 1024 /* ExpectingTypeAnnotation */) !== 0);
+            if (!symbolWithScope) {
+                // If the node is part of a "from X import Y as Z" statement and the node
+                // is the "Y" (non-aliased) name, we need to look up the alias symbol
+                // since the non-aliased name is not in the symbol table.
+                const alias = getAliasFromImport(node);
+                if (alias) {
+                    symbolWithScope = lookUpSymbolRecursive(alias, alias.value, !allowForwardReferences, allowForwardReferences && (flags & 1024 /* ExpectingTypeAnnotation */) !== 0);
+                }
+            }
             if (symbolWithScope) {
                 let useCodeFlowAnalysis = !allowForwardReferences;
                 // If the symbol is implicitly imported from the builtin
@@ -2723,9 +2810,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // If the symbol is declared outside of our execution scope, use its effective
                     // type. If it's declared inside our execution scope, it generally starts
                     // as unbound at the start of the code flow.
-                    const typeAtStart = symbolWithScope.isBeyondExecutionScope || !symbol.isInitiallyUnbound()
-                        ? effectiveType
-                        : types_1.UnboundType.create();
+                    let typeAtStart = effectiveType;
+                    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.
+                        if (symbolWithScope.scope.type === 3 /* Module */) {
+                            (0, debug_1.assert)(symbolWithScope.scope.parent);
+                            const builtInSymbol = symbolWithScope.scope.parent.lookUpSymbol(name);
+                            if (builtInSymbol) {
+                                const builtInEffectiveType = getEffectiveTypeOfSymbolForUsage(builtInSymbol);
+                                typeAtStart = builtInEffectiveType.type;
+                            }
+                        }
+                    }
                     const codeFlowTypeResult = getFlowTypeOfReference(node, symbol.id, typeAtStart, 
                     /* startNode */ undefined, {
                         skipConditionalNarrowing: (flags & 1024 /* ExpectingTypeAnnotation */) !== 0,
@@ -2793,6 +2890,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isTypeVar)(type) &&
             !type.details.isParamSpec &&
+            !type.isVariadicInUnion &&
             (flags & 64 /* ExpectingType */) === 0 &&
             type.details.name === name) {
             // Handle the special case of a PEP 604 union. These can appear within
@@ -2956,7 +3054,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // If this type var is variadic, the name refers to the packed form. It
         // must be unpacked in most contexts.
-        if (type.isVariadicUnpacked) {
+        if ((0, types_1.isUnpackedVariadicTypeVar)(type)) {
             type = types_1.TypeVarType.cloneForPacked(type);
         }
         return type;
@@ -2983,11 +3081,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type.typeAliasInfo.typeParameters &&
                 type.typeAliasInfo.typeParameters.length > 0 &&
                 !type.typeAliasInfo.typeArguments) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForAlias().format({
-                    name: type.typeAliasInfo.name,
-                }), node);
-                type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, new typeVarContext_1.TypeVarContext(type.typeAliasInfo.typeVarScopeId), 
-                /* unknownIfNotFound */ true), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeParameters.map((param) => types_1.UnknownType.create()));
+                let reportMissingTypeArguments = false;
+                const defaultTypeArgs = [];
+                type.typeAliasInfo.typeParameters.forEach((param) => {
+                    if (param.details.defaultType) {
+                        defaultTypeArgs.push(param.details.defaultType);
+                    }
+                    else {
+                        defaultTypeArgs.push(types_1.UnknownType.create());
+                        reportMissingTypeArguments = true;
+                    }
+                });
+                const typeVarContext = (0, typeUtils_1.buildTypeVarContext)(type.typeAliasInfo.typeParameters, defaultTypeArgs, type.typeAliasInfo.typeVarScopeId);
+                if (reportMissingTypeArguments) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForAlias().format({
+                        name: type.typeAliasInfo.name,
+                    }), node);
+                }
+                type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, /* unknownIfNotFound */ true), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, defaultTypeArgs);
             }
         }
         return type;
@@ -3131,9 +3242,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             writeTypeCache(node.memberName, typeResult.type, flags, /* isIncomplete */ true);
             // If the type is initially unbound, see if there's a parent class that
             // potentially initialized the value.
-            let initialType = typeResult.type;
-            let isInitialTypeIncomplete = !!typeResult.isIncomplete;
-            if ((0, types_1.isUnbound)(initialType)) {
+            let typeAtStart = typeResult.type;
+            let isTypeAtStartIncomplete = !!typeResult.isIncomplete;
+            if ((0, types_1.isUnbound)(typeAtStart)) {
                 const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
                 let classMemberInfo;
                 if ((0, types_1.isInstantiableClass)(baseType)) {
@@ -3143,14 +3254,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, node.memberName.value, 1 /* SkipOriginalClass */);
                 }
                 if (classMemberInfo) {
-                    initialType = getTypeOfMember(classMemberInfo);
-                    isInitialTypeIncomplete = false;
+                    typeAtStart = getTypeOfMember(classMemberInfo);
+                    isTypeAtStartIncomplete = false;
                 }
             }
             // See if we can refine the type based on code flow analysis.
-            const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, initialType, 
+            const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, typeAtStart, 
             /* startNode */ undefined, {
-                isInitialTypeIncomplete,
+                isTypeAtStartIncomplete,
                 skipConditionalNarrowing: (flags & 1024 /* ExpectingTypeAnnotation */) !== 0,
             });
             if (codeFlowTypeResult.type) {
@@ -4051,7 +4162,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // See if we can refine the type based on code flow analysis.
                 const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, indexTypeResult.type, 
                 /* startNode */ undefined, {
-                    isInitialTypeIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
+                    isTypeAtStartIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
                     skipConditionalNarrowing: (flags & 1024 /* ExpectingTypeAnnotation */) !== 0,
                 });
                 if (codeFlowTypeResult.type) {
@@ -4080,6 +4191,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return indexTypeResult;
     }
     function adjustTypeArgumentsForVariadicTypeVar(typeArgs, typeParameters, errorNode) {
+        var _a;
         const variadicIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         // Do we need to adjust the type arguments to map to a variadic type
         // param at the end of the list?
@@ -4127,7 +4239,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Add an empty tuple that maps to the TypeVarTuple type parameter.
                     typeArgs.push({
                         node: errorNode,
-                        type: (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
+                        type: (_a = typeParameters[variadicIndex].details.defaultType) !== null && _a !== void 0 ? _a : (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
                         /* isTypeArgumentExplicit */ true, 
                         /* isUnpackedTuple */ true)),
                     });
@@ -4180,7 +4292,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ];
             }
         }
-        if (typeArgs.length > typeParameters.length && !typeParameters.some((typeVar) => typeVar.details.isVariadic)) {
+        if (typeArgs.length > typeParameters.length &&
+            !typeParameters.some((typeVar) => typeVar.details.isVariadic && !typeVar.isVariadicInUnion)) {
             addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
                 name: printType(baseType),
                 expected: typeParameters.length,
@@ -4196,6 +4309,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeVarContext = new typeVarContext_1.TypeVarContext(baseType.typeAliasInfo.typeVarScopeId);
         const diag = new diagnostic_1.DiagnosticAddendum();
         typeParameters.forEach((param, index) => {
+            var _a;
             if (param.details.isParamSpec && index < typeArgs.length) {
                 const typeArgType = typeArgs[index].type;
                 if (typeArgs[index].typeList) {
@@ -4258,7 +4372,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (index < typeArgs.length && typeArgs[index].typeList) {
                     addError(localize_1.Localizer.Diagnostic.typeArgListNotAllowed(), typeArgs[index].node);
                 }
-                const typeArgType = index < typeArgs.length ? (0, typeUtils_1.convertToInstance)(typeArgs[index].type) : types_1.UnknownType.create();
+                const typeArgType = index < typeArgs.length
+                    ? (0, typeUtils_1.convertToInstance)(typeArgs[index].type)
+                    : (_a = param.details.defaultType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                 (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, typeArgType, diag, typeVarContext, 128 /* RetainLiteralsForTypeVar */);
             }
         });
@@ -4312,7 +4428,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // See if the class has a custom metaclass that supports __getitem__, etc.
                 if (concreteSubtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(concreteSubtype.details.effectiveMetaclass) &&
-                    !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, 'type')) {
+                    !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta'])) {
                     const itemMethodType = getTypeOfClassMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
                     /* usage */ undefined, 
                     /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */);
@@ -4370,7 +4486,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (concreteSubtype.typeArguments) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classAlreadySpecialized().format({
-                        type: printType((0, typeUtils_1.convertToInstance)(concreteSubtype), /* expandTypeAlias */ true),
+                        type: printType((0, typeUtils_1.convertToInstance)(concreteSubtype), { expandTypeAlias: true }),
                     }), node.baseExpression);
                     return concreteSubtype;
                 }
@@ -4552,12 +4668,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
             unpackedListArgs.forEach((arg) => {
+                var _a, _b;
                 const typeResult = getTypeOfExpression(arg.valueExpression);
-                const exprType = typeResult.type;
                 if (typeResult.isIncomplete) {
                     isPositionalIndexTypeIncomplete = true;
                 }
-                const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg.valueExpression) || types_1.UnknownType.create();
+                const iterableType = (_b = (_a = getTypeOfIterator(typeResult, /* isAsync */ false, arg.valueExpression)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 tupleEntries.push(iterableType);
             });
             positionalIndexType = makeTupleObject(tupleEntries, unpackedListArgs.length > 0);
@@ -4640,7 +4756,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             adjFlags &= ~(2 /* DoNotSpecialize */ |
                 32 /* ParamSpecDisallowed */ |
                 128 /* TypeVarTupleDisallowed */ |
-                1048576 /* RequiredAllowed */);
+                1048576 /* RequiredAllowed */ |
+                16384 /* EnforceTypeVarVarianceConsistency */);
             if (!isAnnotatedClass) {
                 adjFlags |= 131072 /* ClassVarDisallowed */ | 16 /* FinalDisallowed */;
             }
@@ -5036,7 +5153,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, expectedType);
         const type = typeResult.type;
         const exprString = ParseTreeUtils.printExpression(arg0Value);
-        const typeString = printType(type, /* expandTypeAlias */ true);
+        const typeString = printType(type, { expandTypeAlias: true });
         if (expectedText !== undefined) {
             if (expectedText !== typeString) {
                 addError(localize_1.Localizer.Diagnostic.revealTypeExpectedTextMismatch().format({
@@ -5076,7 +5193,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const typeOfSymbol = getEffectiveTypeOfSymbol(symbol);
                     infoMessages.push(localize_1.Localizer.DiagnosticAddendum.typeOfSymbol().format({
                         name,
-                        type: printType(typeOfSymbol, /* expandTypeAlias */ true),
+                        type: printType(typeOfSymbol, { expandTypeAlias: true }),
                     }));
                 }
             });
@@ -5811,7 +5928,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const exprNode = errorNode.nodeType === 9 /* Call */ ? errorNode.leftExpression : errorNode;
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotCallable().format({
                 expression: ParseTreeUtils.printExpression(exprNode),
-                type: printType(callTypeResult.type, /* expandTypeAlias */ true),
+                type: printType(callTypeResult.type, { expandTypeAlias: true }),
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
@@ -6129,18 +6246,64 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             specializedInitSelfType,
         };
     }
+    // Expands any unpacked tuples within an argument list.
+    function expandArgList(argList) {
+        var _a;
+        const expandedArgList = [];
+        for (const arg of argList) {
+            if (arg.argumentCategory === 1 /* UnpackedList */) {
+                const argType = getTypeOfArgument(arg).type;
+                // If this is a tuple with specified element types, use those
+                // specified types rather than using the more generic iterator
+                // type which will be a union of all element types.
+                const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), tupleClassType);
+                if ((0, types_1.isClassInstance)(combinedArgType) && (0, typeUtils_1.isTupleClass)(combinedArgType)) {
+                    const tupleTypeArgs = (_a = combinedArgType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [];
+                    if (tupleTypeArgs.length !== 1) {
+                        for (const tupleTypeArg of tupleTypeArgs) {
+                            if (tupleTypeArg.isUnbounded) {
+                                expandedArgList.push({
+                                    ...arg,
+                                    argumentCategory: 1 /* UnpackedList */,
+                                    valueExpression: undefined,
+                                    typeResult: {
+                                        type: (0, typeUtils_1.specializeTupleClass)(combinedArgType, [tupleTypeArg]),
+                                    },
+                                });
+                            }
+                            else {
+                                expandedArgList.push({
+                                    ...arg,
+                                    argumentCategory: 0 /* Simple */,
+                                    valueExpression: undefined,
+                                    typeResult: {
+                                        type: tupleTypeArg.type,
+                                    },
+                                });
+                            }
+                        }
+                        continue;
+                    }
+                }
+            }
+            expandedArgList.push(arg);
+        }
+        return expandedArgList;
+    }
     // Matches the arguments passed to a function to the corresponding parameters in that
     // function. This matching is done based on positions and keywords. Type evaluation and
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchFunctionArgumentsToParameters(errorNode, argList, type, overloadIndex) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         const paramDetails = (0, typeUtils_1.getParameterListDetails)(type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
         let reportedArgError = false;
         let isTypeIncomplete = false;
         let isVariadicTypeVarFullyMatched = false;
+        // Expand any unpacked tuples in the arg list.
+        argList = expandArgList(argList);
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
@@ -6224,24 +6387,44 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 activeParam = param;
             }
         }
-        let foundUnpackedListArg = argList.find((arg) => arg.argumentCategory === 1 /* UnpackedList */) !== undefined;
+        const foundUnpackedListArg = argList.find((arg) => arg.argumentCategory === 1 /* UnpackedList */) !== undefined;
         // Map the positional args to parameters.
         let paramIndex = 0;
-        let unpackedArgIndex = 0;
         while (argIndex < positionalArgCount) {
             if (argIndex < positionalOnlyLimitIndex && argList[argIndex].name) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(argList[argIndex].name);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argPositional(), argList[argIndex].name);
                 reportedArgError = true;
             }
+            const remainingArgCount = positionalArgCount - argIndex;
+            const remainingParamCount = positionParamLimitIndex - paramIndex - 1;
             if (paramIndex >= positionParamLimitIndex) {
-                if (!foundUnpackedListArg || argList[argIndex].argumentCategory !== 1 /* UnpackedList */) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                        ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                        : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                            expected: positionParamLimitIndex,
-                        }), argList[argIndex].valueExpression || errorNode);
-                    reportedArgError = true;
+                if (!type.details.paramSpec) {
+                    let tooManyPositionals = false;
+                    if (foundUnpackedListArg && argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
+                        // If this is an unpacked iterable, we will conservatively assume that it
+                        // might have zero iterations unless we can tell from its type that it
+                        // definitely has at least one iterable value.
+                        const argType = getTypeOfArgument(argList[argIndex]).type;
+                        if ((0, types_1.isClassInstance)(argType) &&
+                            (0, typeUtils_1.isTupleClass)(argType) &&
+                            !(0, typeUtils_1.isUnboundedTupleClass)(argType) &&
+                            argType.tupleTypeArguments !== undefined &&
+                            argType.tupleTypeArguments.length > 0) {
+                            tooManyPositionals = true;
+                        }
+                    }
+                    else {
+                        tooManyPositionals = true;
+                    }
+                    if (tooManyPositionals) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                            ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
+                            : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                expected: positionParamLimitIndex,
+                            }), (_b = argList[argIndex].valueExpression) !== null && _b !== void 0 ? _b : errorNode);
+                        reportedArgError = true;
+                    }
                 }
                 break;
             }
@@ -6250,15 +6433,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             (0, debug_1.assert)(paramDetails.params[paramIndex], 'paramIndex params entry is undefined');
             const paramType = paramDetails.params[paramIndex].type;
+            const paramName = paramDetails.params[paramIndex].param.name;
+            const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
+                (0, types_1.isVariadicTypeVar)(paramType);
             if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
-                if (!argList[argIndex].valueExpression) {
-                    break;
-                }
-                const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
-                    (0, types_1.isVariadicTypeVar)(paramType);
                 let isArgCompatibleWithVariadic = false;
                 const argTypeResult = getTypeOfArgument(argList[argIndex]);
-                const argType = argTypeResult.type;
                 let listElementType;
                 let advanceToNextArg = false;
                 // Handle the case where *args is being passed to a function defined
@@ -6270,32 +6450,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
                         : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
                             expected: positionParamLimitIndex,
-                        }), argList[argIndex].valueExpression || errorNode);
+                        }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
                     reportedArgError = true;
                 }
-                // If this is a tuple with specified element types, use those
-                // specified types rather than using the more generic iterator
-                // type which will be a union of all element types.
-                const combinedTupleType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), tupleClassType);
-                if (!isParamVariadic &&
-                    combinedTupleType &&
-                    (0, types_1.isClassInstance)(combinedTupleType) &&
-                    combinedTupleType.tupleTypeArguments &&
-                    combinedTupleType.tupleTypeArguments.length > 0 &&
-                    unpackedArgIndex < combinedTupleType.tupleTypeArguments.length) {
-                    listElementType = combinedTupleType.tupleTypeArguments[unpackedArgIndex].type;
-                    // Determine if there are any more unpacked list arguments after
-                    // this one. If not, we'll clear this flag because this unpacked
-                    // list arg is bounded in length.
-                    foundUnpackedListArg =
-                        argList.find((arg, index) => index > argIndex && arg.argumentCategory === 1 /* UnpackedList */) !== undefined;
-                    unpackedArgIndex++;
-                    if (unpackedArgIndex >= combinedTupleType.tupleTypeArguments.length) {
-                        unpackedArgIndex = 0;
-                        advanceToNextArg = true;
-                    }
-                }
-                else if (isParamVariadic && (0, types_1.isVariadicTypeVar)(argType)) {
+                const argType = argTypeResult.type;
+                if (isParamVariadic && (0, types_1.isUnpackedVariadicTypeVar)(argType)) {
                     // Allow an unpacked variadic type variable to satisfy an
                     // unpacked variadic type variable.
                     listElementType = argType;
@@ -6307,7 +6466,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, typeUtils_1.isTupleClass)(argType) &&
                     argType.tupleTypeArguments &&
                     argType.tupleTypeArguments.length === 1 &&
-                    (0, types_1.isVariadicTypeVar)(argType.tupleTypeArguments[0].type)) {
+                    (0, types_1.isUnpackedVariadicTypeVar)(argType.tupleTypeArguments[0].type)) {
                     // Handle the case where an unpacked variadic type var has
                     // been packaged into a tuple.
                     listElementType = argType.tupleTypeArguments[0].type;
@@ -6315,13 +6474,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     advanceToNextArg = true;
                     isVariadicTypeVarFullyMatched = true;
                 }
+                else if (isParamVariadic && (0, types_1.isClassInstance)(argType) && (0, typeUtils_1.isTupleClass)(argType)) {
+                    // Handle the case where an unpacked tuple argument is
+                    // matched to a TypeVarTuple parameter.
+                    isArgCompatibleWithVariadic = true;
+                    advanceToNextArg = true;
+                    // Determine whether we should treat the variadic type as fully matched.
+                    // This depends on how many args and unmatched parameters exist.
+                    if (remainingArgCount < remainingParamCount) {
+                        isVariadicTypeVarFullyMatched = true;
+                    }
+                    listElementType = types_1.ClassType.cloneForUnpacked(argType);
+                }
                 else if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'args') {
                     listElementType = undefined;
                 }
                 else {
                     listElementType =
-                        getTypeOfIterator(argType, /* isAsync */ false, argList[argIndex].valueExpression) ||
-                            types_1.UnknownType.create();
+                        (_e = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
+                        /* isAsync */ false, argList[argIndex].valueExpression)) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
                     if (paramDetails.params[paramIndex].param.category !== 1 /* VarArgList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
@@ -6335,7 +6506,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (funcArg && argTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
-                const paramName = paramDetails.params[paramIndex].param.name;
                 // It's not allowed to use unpacked arguments with a variadic *args
                 // parameter unless the argument is a variadic arg as well.
                 if (isParamVariadic && !isArgCompatibleWithVariadic) {
@@ -6355,6 +6525,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             errorNode: argList[argIndex].valueExpression || errorNode,
                             paramName,
                             isParamNameSynthesized: paramDetails.params[paramIndex].param.isNameSynthesized,
+                            mapsToVarArgList: isParamVariadic && remainingArgCount > remainingParamCount,
                         });
                     }
                 }
@@ -6392,8 +6563,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     paramCategory = (0, types_1.isVariadicTypeVar)(effectiveParamType)
                         ? 1 /* VarArgList */
                         : 0 /* Simple */;
-                    const remainingArgCount = positionalArgCount - argIndex;
-                    const remainingParamCount = positionParamLimitIndex - paramIndex - 1;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
                             // Have we run out of arguments and still have parameters left to fill?
@@ -6796,7 +6965,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 !isVariadicTypeVarFullyMatched) {
                 const paramType = paramDetails.params[paramDetails.argsIndex].type;
                 const variadicArgs = validateArgTypeParams.filter((argParam) => argParam.mapsToVarArgList);
-                if ((0, types_1.isTypeVar)(paramType) && paramType.details.isVariadic) {
+                if ((0, types_1.isVariadicTypeVar)(paramType) && !paramType.isVariadicInUnion) {
                     if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                         const tupleTypeArgs = variadicArgs.map((argParam) => {
                             var _a;
@@ -6816,9 +6985,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 isUnbounded: argParam.argument.argumentCategory === 1 /* UnpackedList */,
                             };
                         });
-                        const specializedTuple = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleTypeArgs, 
-                        /* isTypeArgumentExplicit */ true, 
-                        /* isUnpackedTuple */ true));
+                        let specializedTuple;
+                        if (tupleTypeArgs.length === 1 &&
+                            !tupleTypeArgs[0].isUnbounded &&
+                            ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isVariadicTypeVar)(tupleTypeArgs[0].type))) {
+                            // If there is a single unpacked tuple or unpacked variadic type variable
+                            // (including an unpacked TypeVarTuple union) within this tuple,
+                            // simplify the type.
+                            specializedTuple = tupleTypeArgs[0].type;
+                        }
+                        else {
+                            specializedTuple = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleTypeArgs, 
+                            /* isTypeArgumentExplicit */ true, 
+                            /* isUnpackedTuple */ true));
+                        }
                         const combinedArg = {
                             paramCategory: 1 /* VarArgList */,
                             paramType,
@@ -7500,7 +7680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!suppressPartialUnknown) {
                         const diagAddendum = getDiagAddendum();
                         diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentType().format({
-                            type: printType(simplifiedType, /* expandTypeAlias */ true),
+                            type: printType(simplifiedType, { expandTypeAlias: true }),
                         }));
                         addDiagnostic(fileInfo.diagnosticRuleSet.reportUnknownArgumentType, diagnosticRules_1.DiagnosticRule.reportUnknownArgumentType, localize_1.Localizer.Diagnostic.argTypePartiallyUnknown() + diagAddendum.getString(), argParam.errorNode);
                     }
@@ -7510,9 +7690,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { isCompatible, argType, isTypeIncomplete, condition };
     }
     function createTypeVarType(errorNode, argList) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
         let typeVarName = '';
         let firstConstraintArg;
+        let defaultValueNode;
         if (argList.length === 0) {
             addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), errorNode);
             return undefined;
@@ -7526,10 +7707,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false);
         // Parse the remaining parameters.
+        const paramNameMap = new Map();
         for (let i = 1; i < argList.length; i++) {
             const paramNameNode = argList[i].name;
             const paramName = paramNameNode ? paramNameNode.value : undefined;
-            const paramNameMap = new Map();
             if (paramName) {
                 if (paramNameMap.get(paramName)) {
                     addError(localize_1.Localizer.Diagnostic.duplicateParam().format({ name: paramName }), argList[i].valueExpression || errorNode);
@@ -7541,14 +7722,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else {
                         const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
                         if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
-                            addError(localize_1.Localizer.Diagnostic.typeVarGeneric(), argList[i].valueExpression || errorNode);
+                            addError(localize_1.Localizer.Diagnostic.typeVarBoundGeneric(), argList[i].valueExpression || errorNode);
                         }
                         typeVar.details.boundType = (0, typeUtils_1.convertToInstance)(argType);
                     }
                 }
                 else if (paramName === 'covariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.declaredVariance === 4 /* Contravariant */) {
+                        if (typeVar.details.declaredVariance === 4 /* Contravariant */ ||
+                            typeVar.details.declaredVariance === 0 /* Auto */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
@@ -7558,7 +7740,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (paramName === 'contravariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.declaredVariance === 3 /* Covariant */) {
+                        if (typeVar.details.declaredVariance === 3 /* Covariant */ ||
+                            typeVar.details.declaredVariance === 0 /* Auto */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
@@ -7566,8 +7749,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
+                else if (paramName === 'infer_variance') {
+                    if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
+                        if (typeVar.details.declaredVariance === 3 /* Covariant */ ||
+                            typeVar.details.declaredVariance === 4 /* Contravariant */) {
+                            addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
+                        }
+                        else {
+                            typeVar.details.declaredVariance = 0 /* Auto */;
+                        }
+                    }
+                }
+                else if (paramName === 'default') {
+                    defaultValueNode = argList[i].valueExpression;
+                    const argType = (_d = (_c = argList[i].typeResult) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
+                    typeVar.details.defaultType = (0, typeUtils_1.convertToInstance)(argType);
+                }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_c = argList[i].node) === null || _c === void 0 ? void 0 : _c.name) || argList[i].valueExpression || errorNode);
+                    addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_e = argList[i].node) === null || _e === void 0 ? void 0 : _e.name) || argList[i].valueExpression || errorNode);
                 }
                 paramNameMap.set(paramName, paramName);
             }
@@ -7576,9 +7775,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
-                    const argType = (_e = (_d = argList[i].typeResult) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
+                    const argType = (_g = (_f = argList[i].typeResult) === null || _f === void 0 ? void 0 : _f.type) !== null && _g !== void 0 ? _g : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
                     if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
-                        addError(localize_1.Localizer.Diagnostic.typeVarGeneric(), argList[i].valueExpression || errorNode);
+                        addError(localize_1.Localizer.Diagnostic.typeVarConstraintGeneric(), argList[i].valueExpression || errorNode);
                     }
                     types_1.TypeVarType.addConstraint(typeVar, (0, typeUtils_1.convertToInstance)(argType));
                     if (firstConstraintArg === undefined) {
@@ -7590,6 +7789,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeVar.details.constraints.length === 1 && firstConstraintArg) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarSingleConstraint(), firstConstraintArg.valueExpression || errorNode);
         }
+        // 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 = (0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, 
+            /* unknownIfNotFound */ true);
+            if (typeVar.details.boundType) {
+                if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultBoundMismatch(), defaultValueNode);
+                }
+            }
+            else if (typeVar.details.constraints.length > 0) {
+                if (!typeVar.details.constraints.some((constraint) => (0, types_1.isTypeSame)(constraint, concreteDefaultType))) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultConstraintMismatch(), defaultValueNode);
+                }
+            }
+        }
         return typeVar;
     }
     function createTypeVarTupleType(errorNode, argList) {
@@ -7610,12 +7826,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeVar.details.isVariadic = true;
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
-            addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
+            const paramNameNode = argList[i].name;
+            const paramName = paramNameNode ? paramNameNode.value : undefined;
+            if (paramName) {
+                if (paramName === 'default') {
+                    const expr = argList[i].valueExpression;
+                    if (expr) {
+                        typeVar.details.defaultType = getTypeVarTupleDefaultType(expr);
+                    }
+                }
+                else {
+                    addError(localize_1.Localizer.Diagnostic.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
+                }
+            }
         }
         return typeVar;
     }
+    function getTypeVarTupleDefaultType(node) {
+        const argType = getTypeOfExpressionExpectingType(node, { allowUnpackedTuple: true }).type;
+        const isUnpackedTuple = (0, types_1.isClass)(argType) && (0, typeUtils_1.isTupleClass)(argType) && argType.isUnpacked;
+        const isUnpackedTypeVarTuple = (0, types_1.isUnpackedVariadicTypeVar)(argType);
+        if (!isUnpackedTuple && !isUnpackedTypeVarTuple) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarTupleDefaultNotUnpacked(), node);
+            return undefined;
+        }
+        return (0, typeUtils_1.convertToInstance)(argType);
+    }
     function createParamSpecType(errorNode, argList) {
-        var _a, _b;
         if (argList.length === 0) {
             addError(localize_1.Localizer.Diagnostic.paramSpecFirstArg(), errorNode);
             return undefined;
@@ -7631,8 +7868,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const paramSpec = types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true);
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
-            if ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) {
-                addError(localize_1.Localizer.Diagnostic.paramSpecUnknownParam().format({ name: argList[i].name.value }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
+            const paramNameNode = argList[i].name;
+            const paramName = paramNameNode ? paramNameNode.value : undefined;
+            if (paramName) {
+                if (paramName === 'default') {
+                    const expr = argList[i].valueExpression;
+                    if (expr) {
+                        paramSpec.details.defaultType = getParamSpecDefaultType(expr);
+                    }
+                }
+                else {
+                    addError(localize_1.Localizer.Diagnostic.paramSpecUnknownParam().format({ name: paramName }), paramNameNode || argList[i].valueExpression || errorNode);
+                }
             }
             else {
                 addError(localize_1.Localizer.Diagnostic.paramSpecUnknownArg(), argList[i].valueExpression || errorNode);
@@ -7641,6 +7888,42 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return paramSpec;
     }
+    function getParamSpecDefaultType(node) {
+        const functionType = types_1.FunctionType.createSynthesizedInstance('', 32768 /* SkipArgsKwargsCompatibilityCheck */ | 65536 /* ParamSpecValue */);
+        types_1.TypeBase.setSpecialForm(functionType);
+        if (node.nodeType === 18 /* Ellipsis */) {
+            types_1.FunctionType.addDefaultParameters(functionType);
+            return functionType;
+        }
+        if (node.nodeType === 52 /* Tuple */) {
+            node.expressions.forEach((paramExpr, index) => {
+                const typeResult = getTypeOfExpressionExpectingType(paramExpr);
+                types_1.FunctionType.addParameter(functionType, {
+                    category: 0 /* Simple */,
+                    name: `__p${index}`,
+                    isNameSynthesized: true,
+                    hasDeclaredType: true,
+                    type: (0, typeUtils_1.convertToInstance)(typeResult.type),
+                });
+            });
+            // Update the type cache so we don't attempt to re-evaluate this node.
+            // The type doesn't matter, so use Any.
+            writeTypeCache(node, types_1.AnyType.create(), /* flags */ undefined, /* isIncomplete */ false);
+            return functionType;
+        }
+        else {
+            const typeResult = getTypeOfExpressionExpectingType(node, { allowParamSpec: true });
+            if (typeResult.typeErrors) {
+                return undefined;
+            }
+            if ((0, types_1.isParamSpec)(typeResult.type)) {
+                functionType.details.paramSpec = typeResult.type;
+                return functionType;
+            }
+        }
+        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecDefaultNotTuple(), node);
+        return undefined;
+    }
     function getBooleanValue(node) {
         if (node.nodeType === 11 /* Constant */) {
             if (node.constType === 15 /* False */) {
@@ -8166,6 +8449,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type = mapSubtypesExpandTypeVars(rightType, 
                 /* conditionFilter */ undefined, (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
                     return mapSubtypesExpandTypeVars(concreteLeftType, (0, typeUtils_1.getTypeCondition)(rightSubtypeExpanded), (leftSubtype) => {
+                        var _a;
                         if ((0, types_1.isAnyOrUnknown)(leftSubtype) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
                             return (0, typeUtils_1.preserveUnknown)(leftSubtype, rightSubtypeExpanded);
                         }
@@ -8174,9 +8458,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (!returnType) {
                             // If __contains__ was not supported, fall back
                             // on an iterable.
-                            const iteratorType = getTypeOfIterator(rightSubtypeExpanded, 
+                            const iteratorType = (_a = getTypeOfIterator({ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }, 
                             /* isAsync */ false, 
-                            /* errorNode */ undefined);
+                            /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
                             if (iteratorType && assignType(iteratorType, leftSubtype)) {
                                 returnType = getBuiltInObject(errorNode, 'bool');
                             }
@@ -8609,6 +8893,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncomplete = true;
                 }
                 const keyType = keyTypeResult.type;
+                if (!keyTypeResult.isIncomplete && !keyTypeResult.typeErrors) {
+                    verifySetEntryOrDictKeyIsHashable(entryNode.keyExpression, keyType, /* isDictKey */ true);
+                }
                 let valueTypeResult;
                 if (expectedTypedDictEntries &&
                     (0, types_1.isClassInstance)(keyType) &&
@@ -8754,6 +9041,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedType);
         let isIncomplete = false;
         let typeErrors = false;
+        const verifyHashable = node.nodeType === 45 /* Set */;
         if (!(0, types_1.isClassInstance)(expectedType)) {
             return undefined;
         }
@@ -8790,6 +9078,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (entryTypeResult.expectedTypeDiagAddendum) {
                 expectedTypeDiagAddendum.addAddendum(entryTypeResult.expectedTypeDiagAddendum);
             }
+            if (verifyHashable && !entryTypeResult.isIncomplete && !entryTypeResult.typeErrors) {
+                verifySetEntryOrDictKeyIsHashable(entry, entryTypeResult.type, /* isDictKey */ false);
+            }
         });
         const isExpectedTypeListOrSet = (0, types_1.isClassInstance)(expectedType) && types_1.ClassType.isBuiltIn(expectedType, builtInClassName);
         const specializedEntryType = inferTypeArgFromExpectedType(expectedEntryType, entryTypes, 
@@ -8803,6 +9094,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Attempts to infer the type of a list or set statement with no "expected type".
     function getTypeOfListOrSetInferred(node, hasExpectedType) {
         const builtInClassName = node.nodeType === 31 /* List */ ? 'list' : 'set';
+        const verifyHashable = node.nodeType === 45 /* Set */;
         let isEmptyContainer = false;
         let isIncomplete = false;
         let typeErrors = false;
@@ -8813,8 +9105,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 entryTypeResult = getElementTypeFromListComprehension(entry);
             }
             else {
-                entryTypeResult = getTypeOfExpression(entry, 
-                /* flags */ undefined, hasExpectedType ? types_1.NeverType.createNever() : undefined);
+                entryTypeResult = getTypeOfExpression(entry);
             }
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
@@ -8825,6 +9116,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (index < maxEntriesToUseForInference) {
                 entryTypes.push(entryTypeResult.type);
             }
+            if (verifyHashable && !entryTypeResult.isIncomplete && !entryTypeResult.typeErrors) {
+                verifySetEntryOrDictKeyIsHashable(entry, entryTypeResult.type, /* isDictKey */ false);
+            }
         });
         entryTypes = entryTypes.map((t) => stripLiteralValue(t));
         let inferredEntryType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
@@ -8856,6 +9150,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             : types_1.UnknownType.create();
         return { type, isIncomplete, typeErrors };
     }
+    function verifySetEntryOrDictKeyIsHashable(entry, type, isDictKey) {
+        // Verify that the type is hashable.
+        if (!isTypeHashable(type)) {
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(entry);
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.unhashableType().format({ type: printType(type) }));
+            const message = isDictKey
+                ? localize_1.Localizer.Diagnostic.unhashableDictKey()
+                : localize_1.Localizer.Diagnostic.unhashableSetEntry();
+            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), entry);
+        }
+    }
     function inferTypeArgFromExpectedType(expectedType, entryTypes, isNarrowable) {
         let targetTypeVar;
         let useSynthesizedTypeVar = false;
@@ -8956,8 +9262,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type: sentType || types_1.UnknownType.create(), isIncomplete };
     }
     function getTypeOfYieldFrom(node) {
-        var _a;
-        const yieldFromType = getTypeOfExpression(node.expression).type;
+        var _a, _b;
+        const yieldFromTypeResult = getTypeOfExpression(node.expression);
+        const yieldFromType = yieldFromTypeResult.type;
         let generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldFromType);
         let returnedType;
         // Is the expression a Generator type?
@@ -8969,7 +9276,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             returnedType = types_1.UnknownType.create();
         }
         else {
-            const iterableType = (_a = getTypeOfIterable(yieldFromType, /* isAsync */ false, node)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+            const iterableType = (_b = (_a = getTypeOfIterable(yieldFromTypeResult, /* isAsync */ false, node)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
             // Does the iterable return a Generator?
             generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(iterableType);
             if (generatorTypeArgs) {
@@ -9006,9 +9313,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Remove any expected subtypes that don't satisfy the minimum
             // parameter count requirement.
             expectedFunctionTypes = expectedFunctionTypes.filter((functionType) => {
-                const params = types_1.FunctionType.getFunctionParameters(functionType);
-                const functionParamCount = params.filter((param) => !param.hasDefault).length;
-                const hasVarArgs = params.some((param) => param.category !== 0 /* Simple */);
+                const functionParamCount = functionType.details.parameters.filter((param) => !!param.name && !param.hasDefault).length;
+                const hasVarArgs = functionType.details.parameters.some((param) => !!param.name && param.category !== 0 /* Simple */);
                 return (hasVarArgs ||
                     (functionParamCount >= minLambdaParamCount && functionParamCount <= maxLambdaParamCount));
             });
@@ -9099,6 +9405,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type: functionType, isIncomplete };
     }
     function getTypeOfListComprehension(node, expectedType) {
+        var _a;
         let isIncomplete = false;
         let typeErrors = false;
         let isAsync = node.forIfNodes.some((comp) => {
@@ -9112,7 +9419,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedElementType;
         if (expectedType) {
-            expectedElementType = getTypeOfIterator(expectedType, isAsync, /* errorNode */ undefined);
+            expectedElementType = (_a = getTypeOfIterator({ type: expectedType }, isAsync, /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
         }
         const elementTypeResult = getElementTypeFromListComprehension(node, expectedElementType);
         if (elementTypeResult.isIncomplete) {
@@ -9160,7 +9467,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.typeOfSymbol().format({
                     name: nameValue,
-                    type: printType(simplifiedType, /* expandTypeAlias */ true),
+                    type: printType(simplifiedType, { expandTypeAlias: true }),
                 }));
                 addDiagnostic(diagLevel, rule, localize_1.Localizer.Diagnostic.typePartiallyUnknown().format({ name: nameValue }) + diagAddendum.getString(), errorNode);
             }
@@ -9175,9 +9482,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete = true;
             }
             const iterableType = stripLiteralValue(iterableTypeResult.type);
-            const itemType = (_a = getTypeOfIterator(iterableType, !!node.isAsync, node.iterableExpression)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+            const itemTypeResult = (_a = getTypeOfIterator({ type: iterableType, isIncomplete: iterableTypeResult.isIncomplete }, !!node.isAsync, node.iterableExpression)) !== null && _a !== void 0 ? _a : { type: types_1.UnknownType.create(), isIncomplete: iterableTypeResult.isIncomplete };
             const targetExpr = node.targetExpression;
-            assignTypeToExpression(targetExpr, itemType, !!iterableTypeResult.isIncomplete, node.iterableExpression);
+            assignTypeToExpression(targetExpr, itemTypeResult.type, !!itemTypeResult.isIncomplete, node.iterableExpression);
         }
         else {
             (0, debug_1.assert)(node.nodeType === 34 /* ListComprehensionIf */);
@@ -9907,7 +10214,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 // If this is an unpacked TypeVar, note that it is in a union so we can differentiate
                 // between Unpack[Vs] and Union[Unpack[Vs]].
-                if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isVariadicTypeVar)(typeArgType) && typeArgType.isVariadicUnpacked) {
+                if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedVariadicTypeVar)(typeArgType)) {
                     typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
                 }
                 types.push(typeArgType);
@@ -10201,7 +10508,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* honorCodeFlow */ false);
                     if (symbolWithScope) {
                         const decls = symbolWithScope.symbol.getDeclarations();
-                        if (decls.length === 1 && (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decls[0])) {
+                        if (decls.length === 1 && isPossibleTypeAliasOrTypedDict(decls[0])) {
                             typeAliasNameNode = node.leftExpression;
                             isSpeculativeTypeAlias = true;
                         }
@@ -10296,6 +10603,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* allowAssignmentToFinalVar */ true, expectedTypeDiagAddendum);
         writeTypeCache(node, rightHandType, 0 /* None */, isIncomplete);
     }
+    function isPossibleTypeAliasOrTypedDict(decl) {
+        var _a;
+        if ((0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)) {
+            return true;
+        }
+        if (decl.type === 1 /* Variable */ &&
+            decl.node.parent &&
+            decl.node.parent.nodeType === 3 /* Assignment */ &&
+            ((_a = decl.node.parent.rightExpression) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
+            const callLeftNode = decl.node.parent.rightExpression.leftExpression;
+            // Use a simple heuristic to determine whether this is potentially
+            // a call to the TypedDict call. This avoids the expensive (and potentially
+            // recursive) call to getTypeOfExpression in cases where it's not needed.
+            if ((callLeftNode.nodeType === 38 /* Name */ && callLeftNode.value) === 'TypedDict' ||
+                (callLeftNode.nodeType === 35 /* MemberAccess */ &&
+                    callLeftNode.memberName.value === 'TypedDict' &&
+                    callLeftNode.leftExpression.nodeType === 38 /* Name */)) {
+                // See if this is a call to TypedDict. We want to support
+                // recursive type references in a TypedDict call.
+                const callType = getTypeOfExpression(callLeftNode, 2 /* DoNotSpecialize */).type;
+                if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'TypedDict')) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
     // Evaluates the type of a type alias (i.e. "type") statement. This code
     // path does not handle traditional type aliases, which are treated as
     // variables since they use normal variable assignment syntax.
@@ -10765,7 +11099,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (dataClassBehaviors) {
             (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
-            (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, classType, initSubclassArgs);
+            (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.name, classType, initSubclassArgs, dataClassBehaviors);
         }
         // Run any class hooks that depend on this class.
         runClassTypeHooks(classType);
@@ -11002,7 +11336,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isOverloadedFunction)(decoratorType)) {
             const dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
             if (dataclassBehaviors) {
-                (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, originalClassType, dataclassBehaviors, 
+                (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, decoratorNode, originalClassType, dataclassBehaviors, 
                 /* callNode */ undefined);
                 return inputClassType;
             }
@@ -11035,7 +11369,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
             }
             if (dataclassBehaviors) {
-                (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, originalClassType, dataclassBehaviors, callNode);
+                (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, decoratorNode, originalClassType, dataclassBehaviors, callNode);
                 return inputClassType;
             }
         }
@@ -12016,18 +12350,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let useAwaitableGenerator = false;
                         if (functionDecl.yieldStatements) {
                             functionDecl.yieldStatements.forEach((yieldNode) => {
+                                var _a;
                                 if (isNodeReachable(yieldNode)) {
                                     if (yieldNode.nodeType === 61 /* YieldFrom */) {
-                                        const iteratorType = getTypeOfExpression(yieldNode.expression).type;
-                                        if ((0, types_1.isClassInstance)(iteratorType) &&
-                                            types_1.ClassType.isBuiltIn(iteratorType, 'Coroutine')) {
+                                        const iteratorTypeResult = getTypeOfExpression(yieldNode.expression);
+                                        if ((0, types_1.isClassInstance)(iteratorTypeResult.type) &&
+                                            types_1.ClassType.isBuiltIn(iteratorTypeResult.type, 'Coroutine')) {
                                             // Handle old-style (pre-await) Coroutines.
                                             inferredYieldTypes.push();
                                             useAwaitableGenerator = true;
                                         }
                                         else {
-                                            const yieldType = getTypeOfIterator(iteratorType, 
-                                            /* isAsync */ false, yieldNode);
+                                            const yieldType = (_a = getTypeOfIterator(iteratorTypeResult, 
+                                            /* isAsync */ false, yieldNode)) === null || _a === void 0 ? void 0 : _a.type;
                                             inferredYieldTypes.push(yieldType !== null && yieldType !== void 0 ? yieldType : types_1.UnknownType.create());
                                         }
                                     }
@@ -12100,12 +12435,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return true;
     }
     function evaluateTypesForForStatement(node) {
-        var _a;
+        var _a, _b;
         if (readTypeCache(node, 0 /* None */)) {
             return;
         }
         const iteratorTypeResult = getTypeOfExpression(node.iterableExpression);
-        const iteratedType = (_a = getTypeOfIterator(iteratorTypeResult.type, !!node.isAsync, node.iterableExpression)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+        const iteratedType = (_b = (_a = getTypeOfIterator(iteratorTypeResult, !!node.isAsync, node.iterableExpression)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
         assignTypeToExpression(node.targetExpression, iteratedType, !!iteratorTypeResult.isIncomplete, node.targetExpression);
         writeTypeCache(node, iteratedType, 0 /* None */, !!iteratorTypeResult.isIncomplete);
     }
@@ -12115,9 +12450,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (readTypeCache(node, 0 /* None */)) {
             return;
         }
-        const exceptionTypes = getTypeOfExpression(node.typeExpression).type;
+        const exceptionTypeResult = getTypeOfExpression(node.typeExpression);
+        const exceptionTypes = exceptionTypeResult.type;
         function getExceptionType(exceptionType, errorNode) {
-            var _a;
+            var _a, _b;
             exceptionType = makeTopLevelTypeVarsConcrete(exceptionType);
             if ((0, types_1.isAnyOrUnknown)(exceptionType)) {
                 return exceptionType;
@@ -12126,7 +12462,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return types_1.ClassType.cloneAsInstance(exceptionType);
             }
             if ((0, types_1.isClassInstance)(exceptionType)) {
-                const iterableType = (_a = getTypeOfIterator(exceptionType, /* isAsync */ false, errorNode)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+                const iterableType = (_b = (_a = getTypeOfIterator({ type: exceptionType, isIncomplete: exceptionTypeResult.isIncomplete }, 
+                /* isAsync */ false, errorNode)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 return (0, typeUtils_1.mapSubtypes)(iterableType, (subtype) => {
                     if ((0, types_1.isAnyOrUnknown)(subtype)) {
                         return subtype;
@@ -12172,32 +12509,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Verify that the target has an __enter__ or __aenter__ method defined.
         const enterMethodName = isAsync ? '__aenter__' : '__enter__';
         const scopedType = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
-            var _a;
             subtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
             }
-            const diag = new diagnostic_1.DiagnosticAddendum();
             const additionalHelp = new diagnostic_1.DiagnosticAddendum();
-            if ((0, types_1.isClassInstance)(subtype)) {
-                const enterType = (_a = getTypeOfObjectMember(node.expression, subtype, enterMethodName, { method: 'get' }, diag)) === null || _a === void 0 ? void 0 : _a.type;
+            if ((0, types_1.isClass)(subtype)) {
+                let enterType = getTypeOfMagicMethodReturn(subtype, [], enterMethodName, node.expression, 
+                /* expectedType */ undefined);
                 if (enterType) {
-                    let memberReturnType;
-                    if ((0, types_1.isFunction)(enterType)) {
-                        memberReturnType = getFunctionEffectiveReturnType(enterType);
-                    }
-                    else {
-                        memberReturnType = types_1.UnknownType.create();
-                    }
                     // For "async while", an implicit "await" is performed.
                     if (isAsync) {
-                        memberReturnType = getTypeOfAwaitable(memberReturnType, node.expression);
+                        enterType = getTypeOfAwaitable(enterType, node.expression);
                     }
-                    return memberReturnType;
+                    return enterType;
                 }
                 if (!isAsync) {
-                    const memberType = getTypeOfObjectMember(node.expression, subtype, '__aenter__', { method: 'get' }, diag);
-                    if (memberType) {
+                    if (getTypeOfMagicMethodReturn(subtype, [], '__aenter__', node.expression, 
+                    /* expectedType */ undefined)) {
                         additionalHelp.addMessage(localize_1.Localizer.DiagnosticAddendum.asyncHelp());
                     }
                 }
@@ -12214,9 +12543,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return;
             }
-            const diag = new diagnostic_1.DiagnosticAddendum();
-            if ((0, types_1.isClassInstance)(subtype)) {
-                const exitType = getTypeOfObjectMember(node.expression, subtype, exitMethodName, { method: 'get' }, diag);
+            if ((0, types_1.isClass)(subtype)) {
+                const anyArg = { type: types_1.AnyType.create() };
+                const exitType = getTypeOfMagicMethodReturn(subtype, [anyArg, anyArg, anyArg], exitMethodName, node.expression, 
+                /* expectedType */ undefined);
                 if (exitType) {
                     return;
                 }
@@ -12528,6 +12858,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             getTypeOfAnnotation(annotationNode, {
                 isVariableAnnotation: ((_a = annotationNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* TypeAnnotation */,
+                allowUnpackedTuple: annotationParent.nodeType === 41 /* Parameter */ &&
+                    annotationParent.category === 1 /* VarArgList */,
+                allowUnpackedTypedDict: annotationParent.nodeType === 41 /* Parameter */ &&
+                    annotationParent.category === 2 /* VarArgDictionary */,
             });
             return;
         }
@@ -12588,6 +12922,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     break;
                 }
             }
+            else if (parent.nodeType === 48 /* StringList */ && nodeToEvaluate === parent.typeAnnotation) {
+                // Forward-declared type annotation expressions need to be be evaluated
+                // in context so they have the appropriate flags set. Most of these cases
+                // will have been detected above when calling getParentAnnotationNode,
+                // but TypeAlias expressions are not handled there.
+                nodeToEvaluate = parent;
+                continue;
+            }
             else {
                 // Check for expression types that are always contextual.
                 if (nodeToEvaluate.nodeType !== 15 /* Dictionary */ &&
@@ -12903,17 +13245,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Attempts to determine the type of the reference expression at the
     // point in the code. If the code flow analysis has nothing to say
-    // about that expression, it return undefined. Normally flow analysis
-    // starts from the reference node, but startNode can be specified to
-    // override this in a few special cases (functions and lambdas) to
-    // support analysis of captured variables.
-    function getFlowTypeOfReference(reference, targetSymbolId, initialType, startNode, options) {
+    // about that expression, it returns un undefined type. Normally
+    // flow analysis starts from the reference node, but startNode can be
+    // specified to override this in a few special cases (functions and
+    // lambdas) to support analysis of captured variables.
+    function getFlowTypeOfReference(reference, targetSymbolId, typeAtStart, startNode, options) {
         var _a;
         // See if this execution scope requires code flow for this reference expression.
         const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(reference);
         const executionNode = ParseTreeUtils.getExecutionScopeNode((_a = startNode === null || startNode === void 0 ? void 0 : startNode.parent) !== null && _a !== void 0 ? _a : reference);
         const codeFlowExpressions = AnalyzerNodeInfo.getCodeFlowExpressions(executionNode);
-        if (!codeFlowExpressions || !codeFlowExpressions.has(referenceKey)) {
+        if (!codeFlowExpressions ||
+            (!codeFlowExpressions.has(referenceKey) && !codeFlowExpressions.has(codeFlowTypes_1.wildcardImportReferenceKey))) {
             return { type: undefined, isIncomplete: false };
         }
         if (checkCodeFlowTooComplex(reference)) {
@@ -12935,7 +13278,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (flowNode === undefined) {
             return { type: undefined, isIncomplete: false };
         }
-        return analyzer.getTypeFromCodeFlow(flowNode, reference, targetSymbolId, initialType, options);
+        return analyzer.getTypeFromCodeFlow(flowNode, reference, targetSymbolId, typeAtStart, options);
     }
     // Specializes the specified (potentially generic) class type using
     // the specified type arguments, reporting errors as appropriate.
@@ -13068,6 +13411,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const variadicTypeParamIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         if (typeArgs) {
+            let minTypeArgCount = typeParameters.length;
+            const firstNonDefaultParam = typeParameters.findIndex((param) => !!param.details.defaultType);
+            if (firstNonDefaultParam >= 0) {
+                minTypeArgCount = firstNonDefaultParam;
+            }
             if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
@@ -13086,11 +13434,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeArgCount = typeParameters.length;
                 }
             }
-            else if (typeArgCount < typeParameters.length) {
+            else if (typeArgCount < minTypeArgCount) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsTooFew().format({
                     name: classType.aliasName || classType.details.name,
-                    expected: typeParameters.length,
+                    expected: minTypeArgCount,
                     received: typeArgCount,
                 }), typeArgs.length > 0 ? typeArgs[0].node.parent : errorNode);
             }
@@ -13148,6 +13496,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         fullTypeParams.forEach((typeParam, index) => {
+            var _a;
             if (typeArgs && index < typeArgs.length) {
                 if (typeParam.details.isParamSpec) {
                     const typeArg = typeArgs[index];
@@ -13199,7 +13548,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeArgTypes.push((0, typeUtils_1.convertToInstance)(typeArgs[index].type));
                 return;
             }
-            typeArgTypes.push(types_1.UnknownType.create());
+            typeArgTypes.push((_a = typeParam.details.defaultType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create());
         });
         typeArgTypes = typeArgTypes.map((typeArgType, index) => {
             if (index < typeArgCount) {
@@ -13208,19 +13557,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Determine if the variance must match.
                 if (adjustedTypeArgType && (flags & 16384 /* EnforceTypeVarVarianceConsistency */) !== 0) {
                     const destType = typeParameters[index];
-                    if ((0, types_1.isTypeVar)(adjustedTypeArgType) &&
-                        !adjustedTypeArgType.details.isParamSpec &&
-                        !adjustedTypeArgType.details.isVariadic &&
-                        destType.details.declaredVariance !== 0 /* Auto */ &&
-                        adjustedTypeArgType.details.declaredVariance !== 0 /* Auto */) {
-                        if (adjustedTypeArgType.details.declaredVariance !== 2 /* Invariant */ &&
-                            adjustedTypeArgType.details.declaredVariance !== destType.details.declaredVariance) {
-                            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatch().format({
-                                typeVarName: printType(adjustedTypeArgType),
-                                className: classType.details.name,
-                            }));
-                            adjustedTypeArgType = undefined;
-                        }
+                    const declaredVariance = destType.details.declaredVariance;
+                    if (!(0, typeUtils_1.isVarianceOfTypeArgumentCompatible)(adjustedTypeArgType, declaredVariance)) {
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatch().format({
+                            typeVarName: printType(adjustedTypeArgType),
+                            className: classType.details.name,
+                        }));
+                        adjustedTypeArgType = undefined;
                     }
                 }
                 if (adjustedTypeArgType) {
@@ -13272,11 +13615,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // be a value expression from which we can retrieve the type.
         return getTypeOfExpressionExpectingType(arg.valueExpression);
     }
-    function getTypeOfExpressionExpectingType(node, allowFinal = false, allowRequired = false) {
+    function getTypeOfExpressionExpectingType(node, options) {
         let flags = 64 /* ExpectingType */ |
             8 /* EvaluateStringLiteralAsType */ |
-            32 /* ParamSpecDisallowed */ |
-            128 /* TypeVarTupleDisallowed */ |
             131072 /* ClassVarDisallowed */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile) {
@@ -13285,12 +13626,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             flags |= 4194304 /* InterpreterParsesStringLiteral */;
         }
-        if (!allowFinal) {
+        if (!(options === null || options === void 0 ? void 0 : options.allowFinal)) {
             flags |= 16 /* FinalDisallowed */;
         }
-        if (allowRequired) {
+        if (options === null || options === void 0 ? void 0 : options.allowRequired) {
             flags |= 1048576 /* RequiredAllowed */ | 1024 /* ExpectingTypeAnnotation */;
         }
+        if (options === null || options === void 0 ? void 0 : options.allowUnpackedTuple) {
+            flags |= 2097152 /* AllowUnpackedTupleOrTypeVarTuple */;
+        }
+        else {
+            flags |= 128 /* TypeVarTupleDisallowed */;
+        }
+        if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
+            flags |= 32 /* ParamSpecDisallowed */;
+        }
         return getTypeOfExpression(node, flags);
     }
     function getBuiltInType(node, name) {
@@ -13494,6 +13844,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return declarations.length === 0 ? undefined : declarations;
     }
+    function getAliasFromImport(node) {
+        if (node.parent &&
+            node.parent.nodeType === 23 /* ImportFromAs */ &&
+            node.parent.alias &&
+            node === node.parent.name) {
+            return node.parent.alias;
+        }
+        return undefined;
+    }
     function getDeclarationsForNameNode(node, skipUnreachableCode = true) {
         var _a;
         if (skipUnreachableCode && AnalyzerNodeInfo.isCodeUnreachable(node)) {
@@ -13503,14 +13862,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the node is part of a "from X import Y as Z" statement and the node
         // is the "Y" (non-aliased) name, we need to look up the alias symbol
         // since the non-aliased name is not in the symbol table.
-        if (node.parent &&
-            node.parent.nodeType === 23 /* ImportFromAs */ &&
-            node.parent.alias &&
-            node === node.parent.name) {
+        const alias = getAliasFromImport(node);
+        if (alias) {
             const scope = ScopeUtils.getScopeForNode(node);
             if (scope) {
                 // Look up the alias symbol.
-                const symbolInScope = scope.lookUpSymbolRecursive(node.parent.alias.value);
+                const symbolInScope = scope.lookUpSymbolRecursive(alias.value);
                 if (symbolInScope) {
                     // The alias could have more decls that don't refer to this import. Filter
                     // out the one(s) that specifically associated with this import statement.
@@ -13623,7 +13980,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (paramDecl) {
                                 declarations.push(paramDecl);
                             }
-                            else if (types_1.ClassType.isDataClass(baseType)) {
+                            else if (types_1.ClassType.isDataClass(baseType) || types_1.ClassType.isTypedDictClass(baseType)) {
                                 const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
                                 if (lookupResults) {
                                     (0, collectionUtils_1.appendArray)(declarations, lookupResults.symbol.getDeclarations());
@@ -13743,7 +14100,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const constraints = declaration.node.boundExpression.expressions.map((constraint) => {
                             const constraintType = getTypeOfExpressionExpectingType(constraint).type;
                             if ((0, typeUtils_1.requiresSpecialization)(constraintType, /* ignorePseudoGeneric */ true)) {
-                                addError(localize_1.Localizer.Diagnostic.typeVarGeneric(), constraint);
+                                addError(localize_1.Localizer.Diagnostic.typeVarBoundGeneric(), constraint);
                             }
                             return (0, typeUtils_1.convertToInstance)(constraintType);
                         });
@@ -13758,13 +14115,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else {
                         const boundType = getTypeOfExpressionExpectingType(declaration.node.boundExpression).type;
                         if ((0, typeUtils_1.requiresSpecialization)(boundType, /* ignorePseudoGeneric */ true)) {
-                            addError(localize_1.Localizer.Diagnostic.typeVarGeneric(), declaration.node.boundExpression);
+                            addError(localize_1.Localizer.Diagnostic.typeVarConstraintGeneric(), declaration.node.boundExpression);
                         }
                         if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
                             typeVar.details.boundType = (0, typeUtils_1.convertToInstance)(boundType);
                         }
                     }
                 }
+                if (declaration.node.defaultExpression) {
+                    // TODO - need to finish. For now, just evaluate the expression
+                    // to generate any errors.
+                    getTypeOfExpression(declaration.node.defaultExpression, 2097152 /* AllowUnpackedTupleOrTypeVarTuple */);
+                }
                 typeVar.details.isTypeParamSyntax = true;
                 // Associate the type variable with the owning scope.
                 const scopeNode = ParseTreeUtils.getTypeVarScopeNode(declaration.node);
@@ -13794,9 +14156,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         : undefined;
                     let declaredType;
                     if (declaration.isRuntimeTypeExpression) {
-                        declaredType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(typeAnnotationNode, 
-                        /* allowFinal */ true, 
-                        /* allowRequired */ true).type);
+                        declaredType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(typeAnnotationNode, {
+                            allowFinal: true,
+                            allowRequired: true,
+                        }).type);
                     }
                     else {
                         const declNode = declaration.isDefinedByMemberAccess &&
@@ -14054,6 +14417,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
+        var _a;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
             const declaredType = getDeclaredTypeOfSymbol(symbol, usageNode);
@@ -14077,12 +14441,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Look in the cache to see if we've computed this already.
         let cacheEntries = effectiveTypeCache.get(symbol.id);
+        let evaluationAttempts = 0;
         const usageNodeId = usageNode ? usageNode.id : undefined;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
         if (cacheEntries) {
             const result = cacheEntries.get(effectiveTypeCacheKey);
             if (result) {
-                return result;
+                if (!result.isIncomplete) {
+                    return result;
+                }
+                evaluationAttempts = ((_a = result.evaluationAttempts) !== null && _a !== void 0 ? _a : 0) + 1;
             }
         }
         // Infer the type.
@@ -14090,6 +14458,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const decls = symbol.getDeclarations();
         const isFinalVar = (0, symbolUtils_1.isFinalVariable)(symbol);
         let isIncomplete = false;
+        let sawPendingEvaluation = false;
         let includesVariableDecl = false;
         let includesSpeculativeResult = false;
         let declIndexToConsider;
@@ -14138,7 +14507,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (considerDecl) {
                 const isExplicitTypeAlias = (0, declarationUtils_1.isExplicitTypeAliasDeclaration)(decl);
-                const isTypeAlias = isExplicitTypeAlias || (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl);
+                const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(decl);
                 if (isExplicitTypeAlias) {
                     sawExplicitTypeAlias = true;
                 }
@@ -14208,16 +14577,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     isIncomplete = true;
+                    // Note that at least one decl could not be evaluated because
+                    // it was already in the process of being evaluated. Don't set
+                    // this flag if we've already attempted the type evaluation
+                    // many times because this probably means there's a cyclical
+                    // dependency that cannot be broken.
+                    if (evaluationAttempts < maxEffectiveTypeEvaluationAttempts) {
+                        sawPendingEvaluation = true;
+                    }
                 }
             }
         });
         if (typesToCombine.length > 0) {
             const result = {
                 type: (0, types_1.combineTypes)(typesToCombine),
-                isIncomplete: false,
+                isIncomplete: sawPendingEvaluation,
                 includesVariableDecl,
                 includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
                 isRecursiveDefinition: false,
+                evaluationAttempts,
             };
             if (!includesSpeculativeResult) {
                 // Add the entry to the cache so we don't need to compute it next time.
@@ -14235,6 +14613,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             includesVariableDecl,
             includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
             isRecursiveDefinition: false,
+            evaluationAttempts,
         };
     }
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
@@ -14759,9 +15138,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    const removedArgs = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture);
+                    const removedArgTypes = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture).map((t) => {
+                        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
+                            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+                        }
+                        return t.type;
+                    });
                     srcTypeArgs.splice(destUnboundedIndex, 0, {
-                        type: removedArgs.length > 0 ? (0, types_1.combineTypes)(removedArgs.map((t) => t.type)) : types_1.AnyType.create(),
+                        type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
                         isUnbounded: false,
                     });
                 }
@@ -14979,14 +15363,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // and added to the map.
     function assignType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags = 0 /* Default */, recursionCount = 0) {
         var _a, _b;
-        // If this is a one-element union that contains a variadic type variable,
-        // pull out the subtype.
-        if ((0, types_1.isUnion)(destType) && destType.subtypes.length === 1 && (0, types_1.isVariadicTypeVar)(destType.subtypes[0])) {
-            destType = destType.subtypes[0];
-        }
-        if ((0, types_1.isUnion)(srcType) && srcType.subtypes.length === 1 && (0, types_1.isVariadicTypeVar)(srcType.subtypes[0])) {
-            srcType = srcType.subtypes[0];
-        }
         // Handle the case where the dest and src types are the same object.
         // We can normally shortcut this and say that they are compatible,
         // but if the type includes TypeVars, we need to go through
@@ -15238,34 +15614,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Is the src a specialized "Type" object?
-        if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'type')) {
-            const srcTypeArgs = srcType.typeArguments;
+        if ((0, types_1.isClassInstance)(expandedSrcType) && types_1.ClassType.isBuiltIn(expandedSrcType, 'type')) {
+            const srcTypeArgs = expandedSrcType.typeArguments;
+            let typeTypeArg;
+            let instantiableType;
             if (srcTypeArgs && srcTypeArgs.length >= 1) {
-                if ((0, types_1.isAnyOrUnknown)(srcTypeArgs[0])) {
-                    if ((0, types_1.isClassInstance)(destType) && types_1.ClassType.isBuiltIn(srcType, 'type')) {
+                typeTypeArg = srcTypeArgs[0];
+                if ((0, types_1.isAnyOrUnknown)(typeTypeArg)) {
+                    if ((0, types_1.isClassInstance)(destType) && types_1.ClassType.isBuiltIn(expandedSrcType, 'type')) {
                         return true;
                     }
                     return types_1.TypeBase.isInstantiable(destType);
                 }
-                if ((0, types_1.isClassInstance)(srcTypeArgs[0]) || (0, types_1.isTypeVar)(srcTypeArgs[0])) {
-                    if (assignType(destType, (0, typeUtils_1.convertToInstantiable)(srcTypeArgs[0]), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                        return true;
-                    }
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                        sourceType: printType(srcType),
-                        destType: printType(destType),
-                    }));
-                    return false;
+                instantiableType = (0, typeUtils_1.convertToInstantiable)(typeTypeArg);
+            }
+            else {
+                typeTypeArg = objectType !== null && objectType !== void 0 ? objectType : types_1.AnyType.create();
+                instantiableType = expandedSrcType;
+            }
+            if ((0, types_1.isClassInstance)(typeTypeArg) || (0, types_1.isTypeVar)(typeTypeArg)) {
+                if (assignType(destType, instantiableType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    return true;
                 }
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
+                    sourceType: printType(srcType),
+                    destType: printType(destType),
+                }));
+                return false;
             }
         }
         if ((0, types_1.isInstantiableClass)(destType)) {
-            const concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
-            if ((0, types_1.isInstantiableClass)(concreteSrcType)) {
+            if ((0, types_1.isInstantiableClass)(expandedSrcType)) {
                 // PEP 544 says that if the dest type is a Type[Proto] class,
                 // the source must be a "concrete" (non-protocol) class.
                 if (types_1.ClassType.isProtocolClass(destType)) {
-                    if (types_1.ClassType.isProtocolClass(concreteSrcType) &&
+                    if (types_1.ClassType.isProtocolClass(expandedSrcType) &&
                         (0, types_1.isInstantiableClass)(srcType) &&
                         !srcType.includeSubclasses) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolSourceIsNotConcrete().format({
@@ -15275,7 +15658,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return false;
                     }
                 }
-                if (assignClass(destType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                if (assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ false)) {
                     return true;
                 }
@@ -15628,6 +16011,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // matches for types like `tuple[Any]` and `tuple[int]` from being considered
     // proper subtypes of each other.
     function isProperSubtype(destType, srcType, recursionCount) {
+        // If the destType has a condition, don't consider the srcType a proper subtype.
+        if (destType.condition) {
+            return false;
+        }
         // Shortcut the check if either type is Any or Unknown.
         if ((0, types_1.isAnyOrUnknown)(destType) || (0, types_1.isAnyOrUnknown)(srcType)) {
             return true;
@@ -15694,9 +16081,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If so, we need to use a slower path.
         if (!(0, typeUtils_1.requiresSpecialization)(destType)) {
             for (const subtype of destType.subtypes) {
-                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), 
-                /* destTypeVarContextClone */ undefined, 
-                /* srcTypeVarContextClone */ undefined, flags, recursionCount)) {
+                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                     foundMatch = true;
                     break;
                 }
@@ -16394,7 +16779,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const effectiveDestType = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? destType : srcType;
             const effectiveSrcType = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? srcType : destType;
             if (effectiveDestType.details.paramSpec) {
-                const requiredMatchParamCount = types_1.FunctionType.getFunctionParameters(effectiveDestType).filter((p) => {
+                const requiredMatchParamCount = effectiveDestType.details.parameters.filter((p) => {
+                    if (!p.name) {
+                        return false;
+                    }
                     if (p.category === 0 /* Simple */ && (0, types_1.isParamSpec)(p.type)) {
                         return false;
                     }
@@ -16421,6 +16809,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             name: p.name,
                             isNameSynthesized: p.isNameSynthesized,
                             hasDefault: !!p.hasDefault,
+                            defaultValueExpression: p.defaultValueExpression,
                             type: types_1.FunctionType.getEffectiveParameterType(effectiveSrcType, index),
                         });
                     }
@@ -16515,7 +16904,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // replace that type argument in the assigned type. This function assumes
     // that the caller has already verified that the assignedType is assignable
     // to the declaredType.
-    function replaceTypeArgsWithAny(declaredType, assignedType) {
+    function replaceTypeArgsWithAny(declaredType, assignedType, recursionCount = 0) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return undefined;
+        }
+        recursionCount++;
         // If this is a tuple with defined tuple type arguments, don't overwrite them.
         if (assignedType.tupleTypeArguments) {
             return undefined;
@@ -16536,6 +16929,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         replacedTypeArg = true;
                         return expectedTypeArgType;
                     }
+                    else if ((0, types_1.isClassInstance)(expectedTypeArgType) && (0, types_1.isClassInstance)(typeArg)) {
+                        // Recursively replace Any in the type argument.
+                        const recursiveReplacement = replaceTypeArgsWithAny(expectedTypeArgType, typeArg, recursionCount);
+                        if (recursiveReplacement) {
+                            replacedTypeArg = true;
+                            return recursiveReplacement;
+                        }
+                    }
                 }
                 return typeArg;
             });
@@ -16575,10 +16976,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // use the concrete type.
                         return declaredSubtype;
                     }
-                    else if ((0, types_1.isAnyOrUnknown)(assignedSubtype)) {
-                        // Any or Unknown do not narrow because they're assignable to all types.
-                        return declaredSubtype;
-                    }
                     return assignedSubtype;
                 }
                 return undefined;
@@ -16591,7 +16988,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return narrowedSubtype;
         });
         // If the result of narrowing is Any, stick with the declared (unnarrowed) type.
-        if ((0, types_1.isAnyOrUnknown)(assignedType)) {
+        // If the result of narrowing is an Unknown that is complete, stick with Unknown.
+        // If it's incomplete, propagate the incomplete type for the benefit of
+        // code flow analysis.
+        if ((0, types_1.isAnyOrUnknown)(assignedType) && !(0, typeUtils_1.isIncompleteUnknown)(assignedType)) {
             return declaredType;
         }
         return narrowedType;
@@ -16698,6 +17098,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const overrideParam = overrideParamDetails.params[i].param;
             if (i >= baseParamDetails.positionOnlyParamCount &&
                 !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
+                baseParamDetails.params[i].source !== typeUtils_1.ParameterSource.PositionOnly &&
                 baseParam.category === 0 /* Simple */ &&
                 baseParam.name !== overrideParam.name) {
                 if (overrideParam.category === 0 /* Simple */) {
@@ -17108,11 +17509,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function printFunctionParts(type) {
         return TypePrinter.printFunctionParts(type, evaluatorOptions.printTypeFlags, getFunctionEffectiveReturnType);
     }
-    function printType(type, expandTypeAlias = false) {
+    function printType(type, options) {
         let flags = evaluatorOptions.printTypeFlags;
-        if (expandTypeAlias) {
+        if (options === null || options === void 0 ? void 0 : options.expandTypeAlias) {
             flags |= 32 /* ExpandTypeAlias */;
         }
+        if (options === null || options === void 0 ? void 0 : options.enforcePythonSyntax) {
+            flags |= 256 /* PythonSyntax */;
+        }
+        if (options === null || options === void 0 ? void 0 : options.useTypingUnpack) {
+            flags |= 512 /* UseTypingUnpack */;
+        }
         return TypePrinter.printType(type, flags, getFunctionEffectiveReturnType);
     }
     // Calls back into the parser to parse the contents of a string literal.