@zzzen/pyright-internal 1.1.255 → 1.2.0-dev.20220703

package/dist/analyzer/typeEvaluator.js

@@ -73,6 +73,38 @@ const TypePrinter = __importStar(require("./typePrinter"));
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
 const typeVarContext_1 = require("./typeVarContext");
+var MemberAccessFlags;
+(function (MemberAccessFlags) {
+    MemberAccessFlags[MemberAccessFlags["None"] = 0] = "None";
+    // By default, member accesses are assumed to access the attributes
+    // of a class instance. By setting this flag, only attributes of
+    // the class are considered.
+    MemberAccessFlags[MemberAccessFlags["AccessClassMembersOnly"] = 1] = "AccessClassMembersOnly";
+    // By default, members of base classes are also searched.
+    // Set this flag to consider only the specified class' members.
+    MemberAccessFlags[MemberAccessFlags["SkipBaseClasses"] = 2] = "SkipBaseClasses";
+    // Do not include the "object" base class in the search.
+    MemberAccessFlags[MemberAccessFlags["SkipObjectBaseClass"] = 4] = "SkipObjectBaseClass";
+    // Consider writes to symbols flagged as ClassVars as an error.
+    MemberAccessFlags[MemberAccessFlags["DisallowClassVarWrites"] = 8] = "DisallowClassVarWrites";
+    // Normally __new__ is treated as a static method, but when
+    // it is invoked implicitly through a constructor call, it
+    // acts like a class method instead.
+    MemberAccessFlags[MemberAccessFlags["TreatConstructorAsClassMethod"] = 16] = "TreatConstructorAsClassMethod";
+    // By default, class member lookups start with the class itself
+    // and fall back on the metaclass if it's not found. This option
+    // skips the first check.
+    MemberAccessFlags[MemberAccessFlags["ConsiderMetaclassOnly"] = 32] = "ConsiderMetaclassOnly";
+    // If an attribute cannot be found when looking for instance
+    // members, normally an attribute access override method
+    // (__getattr__, etc.) may provide the missing attribute type.
+    // This disables this check.
+    MemberAccessFlags[MemberAccessFlags["SkipAttributeAccessOverride"] = 64] = "SkipAttributeAccessOverride";
+    // Do not include the class itself, only base classes.
+    MemberAccessFlags[MemberAccessFlags["SkipOriginalClass"] = 128] = "SkipOriginalClass";
+    // Do not include the "type" base class in the search.
+    MemberAccessFlags[MemberAccessFlags["SkipTypeBaseClass"] = 256] = "SkipTypeBaseClass";
+})(MemberAccessFlags || (MemberAccessFlags = {}));
 // Maps binary operators to the magic methods that implement them.
 // The boolean indicates whether the operators "chain" together.
 const binaryOperatorMap = {
@@ -628,15 +660,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeResult.type.details.illegalRecursionDetected = true;
             }
         }
-        // Don't update the type cache with an unbound type that results from
-        // a resolution cycle. The cache will be updated when the stack unwinds
-        // and the type is fully evaluated.
-        if (!(0, typeUtils_1.isTypeAliasPlaceholder)(typeResult.type)) {
-            writeTypeCache(node, typeResult.type, flags, !!typeResult.isIncomplete, expectedType, 
-            /* allowSpeculativeCaching */ true);
-            if (expectedType && !(0, types_1.isAnyOrUnknown)(expectedType) && !(0, types_1.isNever)(expectedType)) {
-                expectedTypeCache.set(node.id, expectedType);
-            }
+        writeTypeCache(node, typeResult.type, flags, !!typeResult.isIncomplete, expectedType, 
+        /* allowSpeculativeCaching */ true);
+        if (expectedType && !(0, types_1.isAnyOrUnknown)(expectedType) && !(0, types_1.isNever)(expectedType)) {
+            expectedTypeCache.set(node.id, expectedType);
         }
         if (printExpressionTypes) {
             printExpressionSpaceCount--;
@@ -1336,7 +1363,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Handle the case where the symbol is a class-level variable
                     // where the type isn't declared in this class but is in
                     // a parent class.
-                    if (getDeclaredTypeOfSymbol(symbol) === undefined &&
+                    if (getDeclaredTypeOfSymbol(symbol, expression) === undefined &&
                         symbolWithScope.scope.type === 2 /* Class */) {
                         const enclosingClass = ParseTreeUtils.getEnclosingClassOrFunction(expression);
                         if (enclosingClass && enclosingClass.nodeType === 10 /* Class */) {
@@ -1354,7 +1381,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 54 /* TypeAnnotation */: {
-                return getDeclaredTypeForExpression(expression.valueExpression);
+                return getDeclaredTypeForExpression(expression.valueExpression, usage);
             }
             case 35 /* MemberAccess */: {
                 const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 2 /* DoNotSpecialize */).type);
@@ -2468,7 +2495,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function setSymbolAccessed(fileInfo, symbol, node) {
         if (!speculativeTypeTracker.isSpeculative(node)) {
-            fileInfo.accessedSymbolMap.set(symbol.id, true);
+            fileInfo.accessedSymbolSet.add(symbol.id);
         }
     }
     function getReturnTypeFromGenerator(type) {
@@ -2508,9 +2535,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function getTypeOfName(node, flags) {
-        var _a;
+        var _a, _b;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
+        let symbol;
         let type;
         let isIncomplete = false;
         const allowForwardReferences = (flags & 4 /* AllowForwardReferences */) !== 0 || fileInfo.isStubFile;
@@ -2524,96 +2552,104 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
             }
         }
-        // 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);
-        if (symbolWithScope) {
-            let useCodeFlowAnalysis = !allowForwardReferences;
-            // If the symbol is implicitly imported from the builtin
-            // scope, there's no need to use code flow analysis.
-            if (symbolWithScope.scope.type === 4 /* Builtin */) {
-                useCodeFlowAnalysis = false;
-            }
-            const symbol = symbolWithScope.symbol;
-            // Get the effective type (either the declared type or the inferred type).
-            // If we're using code flow analysis, pass the usage node so we consider
-            // only the assignment nodes that are reachable from this usage.
-            const effectiveTypeInfo = getEffectiveTypeOfSymbolForUsage(symbol, useCodeFlowAnalysis ? node : undefined);
-            let effectiveType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(effectiveTypeInfo.type);
-            if (effectiveTypeInfo.isIncomplete) {
-                if ((0, types_1.isUnbound)(effectiveType)) {
-                    effectiveType = types_1.UnknownType.create(/* isIncomplete */ true);
-                }
-                isIncomplete = true;
-            }
-            if (effectiveTypeInfo.isRecursiveDefinition && isNodeReachable(node)) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.recursiveDefinition().format({ name }), node);
-            }
-            const isSpecialBuiltIn = !!effectiveType && (0, types_1.isInstantiableClass)(effectiveType) && types_1.ClassType.isSpecialBuiltIn(effectiveType);
-            type = effectiveType;
-            if (useCodeFlowAnalysis && !isSpecialBuiltIn) {
-                // See if code flow analysis can tell us anything more about the type.
-                // 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();
-                const codeFlowTypeResult = getFlowTypeOfReference(node, symbol.id, typeAtStart, 
-                /* isInitialTypeIncomplete */ false, 
-                /* startNode */ undefined);
-                if (codeFlowTypeResult.type) {
-                    type = codeFlowTypeResult.type;
-                }
-                if (codeFlowTypeResult.isIncomplete) {
+        const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
+        if (typeParamSymbol) {
+            symbol = typeParamSymbol;
+            type = (_a = getDeclaredTypeOfSymbol(typeParamSymbol)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+            setSymbolAccessed(fileInfo, symbol, node);
+        }
+        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);
+            if (symbolWithScope) {
+                let useCodeFlowAnalysis = !allowForwardReferences;
+                // If the symbol is implicitly imported from the builtin
+                // scope, there's no need to use code flow analysis.
+                if (symbolWithScope.scope.type === 4 /* Builtin */) {
+                    useCodeFlowAnalysis = false;
+                }
+                symbol = symbolWithScope.symbol;
+                // Get the effective type (either the declared type or the inferred type).
+                // If we're using code flow analysis, pass the usage node so we consider
+                // only the assignment nodes that are reachable from this usage.
+                const effectiveTypeInfo = getEffectiveTypeOfSymbolForUsage(symbol, useCodeFlowAnalysis ? node : undefined);
+                let effectiveType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(effectiveTypeInfo.type);
+                if (effectiveTypeInfo.isIncomplete) {
+                    if ((0, types_1.isUnbound)(effectiveType)) {
+                        effectiveType = types_1.UnknownType.create(/* isIncomplete */ true);
+                    }
                     isIncomplete = true;
                 }
-                if (!codeFlowTypeResult.type && symbolWithScope.isBeyondExecutionScope) {
-                    const outerScopeTypeResult = getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType);
-                    if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.type) {
-                        type = outerScopeTypeResult.type;
-                    }
-                    if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.isIncomplete) {
+                if (effectiveTypeInfo.isRecursiveDefinition && isNodeReachable(node)) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.recursiveDefinition().format({ name }), node);
+                }
+                const isSpecialBuiltIn = !!effectiveType && (0, types_1.isInstantiableClass)(effectiveType) && types_1.ClassType.isSpecialBuiltIn(effectiveType);
+                type = effectiveType;
+                if (useCodeFlowAnalysis && !isSpecialBuiltIn) {
+                    // See if code flow analysis can tell us anything more about the type.
+                    // 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();
+                    const codeFlowTypeResult = getFlowTypeOfReference(node, symbol.id, typeAtStart, 
+                    /* isInitialTypeIncomplete */ false, 
+                    /* startNode */ undefined);
+                    if (codeFlowTypeResult.type) {
+                        type = codeFlowTypeResult.type;
+                    }
+                    if (codeFlowTypeResult.isIncomplete) {
                         isIncomplete = true;
                     }
+                    if (!codeFlowTypeResult.type && symbolWithScope.isBeyondExecutionScope) {
+                        const outerScopeTypeResult = getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType);
+                        if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.type) {
+                            type = outerScopeTypeResult.type;
+                        }
+                        if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.isIncomplete) {
+                            isIncomplete = true;
+                        }
+                    }
                 }
-            }
-            // Detect, report, and fill in missing type arguments if appropriate.
-            type = reportMissingTypeArguments(node, type, flags);
-            setSymbolAccessed(fileInfo, symbol, node);
-            if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
-                // Verify that the name does not refer to a (non type alias) variable.
-                if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
-                    let isAllowedTypeForVariable = (0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type);
-                    if ((0, types_1.isClass)(type) && !type.includeSubclasses) {
-                        // This check exempts class types that are created by calling
-                        // NewType, NamedTuple, and by invoking a metaclass directly.
-                        isAllowedTypeForVariable = true;
-                    }
-                    // Disable for assignments in the typings.pyi file, since it defines special forms.
-                    if (!isAllowedTypeForVariable && !fileInfo.isTypingStubFile) {
-                        // This might be a union that was previously a type alias
-                        // but was reconstituted in such a way that we lost the
-                        // typeAliasInfo. Avoid the false positive error by suppressing
-                        // the error when it looks like a plausible type alias type.
-                        if (effectiveTypeInfo.includesIllegalTypeAliasDecl ||
-                            !types_1.TypeBase.isInstantiable(type) ||
-                            (flags & 2 /* DoNotSpecialize */) !== 0) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationVariable(), node);
-                            type = types_1.UnknownType.create();
+                // Detect, report, and fill in missing type arguments if appropriate.
+                type = reportMissingTypeArguments(node, type, flags);
+                setSymbolAccessed(fileInfo, symbol, node);
+                if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
+                    // Verify that the name does not refer to a (non type alias) variable.
+                    if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
+                        let isAllowedTypeForVariable = (0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type);
+                        if ((0, types_1.isClass)(type) && !type.includeSubclasses) {
+                            // This check exempts class types that are created by calling
+                            // NewType, NamedTuple, and by invoking a metaclass directly.
+                            isAllowedTypeForVariable = true;
+                        }
+                        // Disable for assignments in the typings.pyi file, since it defines special forms.
+                        if (!isAllowedTypeForVariable && !fileInfo.isTypingStubFile) {
+                            // This might be a union that was previously a type alias
+                            // but was reconstituted in such a way that we lost the
+                            // typeAliasInfo. Avoid the false positive error by suppressing
+                            // the error when it looks like a plausible type alias type.
+                            if (effectiveTypeInfo.includesIllegalTypeAliasDecl ||
+                                !types_1.TypeBase.isInstantiable(type) ||
+                                (flags & 2 /* DoNotSpecialize */) !== 0) {
+                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationVariable(), node);
+                                type = types_1.UnknownType.create();
+                            }
                         }
                     }
                 }
             }
-        }
-        else {
-            // Handle the special case of "reveal_type" and "reveal_locals".
-            if (name === 'reveal_type' || name === 'reveal_locals') {
-                type = types_1.AnyType.create();
-            }
             else {
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportUndefinedVariable, diagnosticRules_1.DiagnosticRule.reportUndefinedVariable, localize_1.Localizer.Diagnostic.symbolIsUndefined().format({ name }), node);
-                type = types_1.UnknownType.create();
+                // Handle the special case of "reveal_type" and "reveal_locals".
+                if (name === 'reveal_type' || name === 'reveal_locals') {
+                    type = types_1.AnyType.create();
+                }
+                else {
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportUndefinedVariable, diagnosticRules_1.DiagnosticRule.reportUndefinedVariable, localize_1.Localizer.Diagnostic.symbolIsUndefined().format({ name }), node);
+                    type = types_1.UnknownType.create();
+                }
             }
         }
         if ((0, types_1.isParamSpec)(type)) {
@@ -2628,7 +2664,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             type.details.name === name) {
             // Handle the special case of a PEP 604 union. These can appear within
             // an implied type alias where we are not expecting a type.
-            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* BinaryOperation */ &&
+            const isPep604Union = ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 7 /* BinaryOperation */ &&
                 node.parent.operator === 6 /* BitwiseOr */;
             if (!isPep604Union) {
                 // A TypeVar in contexts where we're not expecting a type is
@@ -2716,6 +2752,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             type = scopedTypeVarInfo.type;
             if ((flags & 2048 /* DisallowTypeVarsWithScopeId */) !== 0 && type.scopeId !== undefined) {
                 if (!type.details.isSynthesized && !type.details.isParamSpec) {
+                    // This TypeVar already has a scope ID assigned to it. See if it
+                    // originates from type parameter syntax. If so, allow it.
+                    if (type.details.isTypeParamSyntax) {
+                        return type;
+                    }
+                    // If this type variable expression is used within a generic class,
+                    // function, or type alias that uses type parameter syntax, there is
+                    // no need to report an error here.
+                    const typeVarScopeNode = ParseTreeUtils.getTypeVarScopeNode(node);
+                    if (typeVarScopeNode &&
+                        typeVarScopeNode.typeParameters &&
+                        !typeVarScopeNode.typeParameters.parameters.some((t) => t.name === node)) {
+                        return type;
+                    }
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarUsedByOuterScope().format({ name: type.details.name }), node);
                 }
             }
@@ -2741,6 +2791,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         }
                         if (enclosingScope) {
+                            // If the enclosing scope is using type parameter syntax, traditional
+                            // type variables can't be used in this context.
+                            if (enclosingScope.typeParameters) {
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeParameterNotDeclared().format({
+                                    name: type.details.name,
+                                    container: enclosingScope.name.value,
+                                }), node);
+                            }
                             type = types_1.TypeVarType.cloneForScopeId(type, getScopeIdForNode(enclosingScope), enclosingScope.name.value, enclosingScope.nodeType === 28 /* Function */
                                 ? 1 /* Function */
                                 : 0 /* Class */);
@@ -2834,50 +2892,48 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Walks up the parse tree to find a function, class, or type alias
     // assignment that provides the context for a type variable.
     function findScopedTypeVar(node, type) {
-        var _a;
         let curNode = node;
         let nestedClassCount = 0;
         (0, debug_1.assert)(types_1.TypeBase.isInstantiable(type));
         while (curNode) {
-            // Generally, getTypeVarScopeNode should not include the function
-            // that contains the TypeVar in its signature, but we make an exception
-            // for TypeVars that are used in a member access expression to accommodate
-            // ParamSpecs (P.args and P.kwargs).
-            curNode = ParseTreeUtils.getTypeVarScopeNode(curNode, ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 35 /* MemberAccess */);
+            curNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
             if (!curNode) {
                 break;
             }
-            let typeVarsForScope;
+            let typeParametersForScope;
+            let scopeUsesTypeParameterSyntax = false;
             if (curNode.nodeType === 10 /* Class */) {
                 const classTypeInfo = getTypeOfClass(curNode);
-                if (classTypeInfo) {
-                    typeVarsForScope = classTypeInfo.classType.details.typeParameters;
+                if (classTypeInfo && !types_1.ClassType.isPartiallyEvaluated(classTypeInfo.classType)) {
+                    typeParametersForScope = classTypeInfo.classType.details.typeParameters;
                 }
+                scopeUsesTypeParameterSyntax = !!curNode.typeParameters;
                 nestedClassCount++;
             }
             else if (curNode.nodeType === 28 /* Function */) {
                 const functionTypeInfo = getTypeOfFunction(curNode);
                 if (functionTypeInfo) {
-                    typeVarsForScope = [];
+                    typeParametersForScope = [];
                     functionTypeInfo.functionType.details.parameters.forEach((param) => {
                         if (param.hasDeclaredType) {
-                            (0, typeUtils_1.addTypeVarsToListIfUnique)(typeVarsForScope, (0, typeUtils_1.getTypeVarArgumentsRecursive)(param.type));
+                            (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersForScope, (0, typeUtils_1.getTypeVarArgumentsRecursive)(param.type));
                         }
                     });
                     if (functionTypeInfo.functionType.details.declaredReturnType) {
-                        (0, typeUtils_1.addTypeVarsToListIfUnique)(typeVarsForScope, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionTypeInfo.functionType.details.declaredReturnType));
+                        (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersForScope, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionTypeInfo.functionType.details.declaredReturnType));
                     }
                 }
+                scopeUsesTypeParameterSyntax = !!curNode.typeParameters;
             }
-            else if (curNode.nodeType === 36 /* Module */) {
-                break;
+            else if (curNode.nodeType === 77 /* TypeAlias */) {
+                scopeUsesTypeParameterSyntax = !!curNode.typeParameters;
             }
-            if (typeVarsForScope) {
-                const match = typeVarsForScope.find((typeVar) => typeVar.details.name === type.details.name);
+            if (typeParametersForScope) {
+                const match = typeParametersForScope.find((typeVar) => typeVar.details.name === type.details.name);
                 if (match === null || match === void 0 ? void 0 : match.scopeId) {
                     // Use the scoped version of the TypeVar rather than the (unscoped) original type.
                     type = types_1.TypeVarType.cloneForScopeId(type, match.scopeId, match.scopeName, match.scopeType);
-                    return { type, foundInterveningClass: nestedClassCount > 1 };
+                    return { type, foundInterveningClass: nestedClassCount > 1 && !scopeUsesTypeParameterSyntax };
                 }
             }
             curNode = curNode.parent;
@@ -2885,14 +2941,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // See if this is part of an assignment statement that is defining a type alias.
         curNode = node;
         while (curNode) {
-            if (curNode.nodeType === 3 /* Assignment */) {
-                const leftType = readTypeCache(curNode.leftExpression, 0 /* None */);
+            let leftType;
+            let typeAliasNode = undefined;
+            if (curNode.nodeType === 77 /* TypeAlias */) {
+                leftType = readTypeCache(curNode.name, 0 /* None */);
+                typeAliasNode = curNode;
+            }
+            else if (curNode.nodeType === 3 /* Assignment */) {
+                leftType = readTypeCache(curNode.leftExpression, 0 /* None */);
+            }
+            if (leftType) {
                 // Is this a placeholder that was temporarily written to the cache for
                 // purposes of resolving type aliases?
                 if (leftType &&
                     (0, types_1.isTypeVar)(leftType) &&
                     leftType.details.recursiveTypeAliasScopeId &&
                     leftType.details.recursiveTypeAliasName) {
+                    // Type alias statements cannot be used with old-style type variables.
+                    if (typeAliasNode && !type.details.isTypeParamSyntax) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeParameterNotDeclared().format({
+                            name: type.details.name,
+                            container: typeAliasNode.name.value,
+                        }), node);
+                    }
                     return {
                         type: types_1.TypeVarType.cloneForScopeId(type, leftType.details.recursiveTypeAliasScopeId, leftType.details.recursiveTypeAliasName, 2 /* TypeAlias */),
                         foundInterveningClass: false,
@@ -4098,7 +4169,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
-            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, undefined, typeArgTypes);
+            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
             return { type, node };
         }
         let isIncomplete = false;
@@ -4773,7 +4844,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgumentExpectingType(node.arguments[1]).type);
         if (!(0, types_1.isTypeSame)(assertedType, arg0TypeResult.type)) {
-            addError(localize_1.Localizer.Diagnostic.assertTypeTypeMismatch().format({
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.assertTypeTypeMismatch().format({
                 expected: printType(assertedType),
                 received: printType(arg0TypeResult.type),
             }), node.arguments[0].valueExpression);
@@ -5157,7 +5228,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function validateOverloadedFunctionArguments(errorNode, argList, type, typeVarContext, skipUnknownArgCheck, expectedType) {
         let filteredMatchResults = [];
-        let contextFreeArgTypes = [];
+        let contextFreeArgTypes;
         // Start by evaluating the types of the arguments without any expected
         // type. Also, filter the list of overloads based on the number of
         // positional and named arguments that are present. We do all of this
@@ -5177,21 +5248,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     overloadIndex++;
                 }
             });
-            // Also evaluate the types of each argument expression without regard to
-            // the expectedType. We'll use this to determine whether we need to do
-            // union expansion.
-            contextFreeArgTypes = argList.map((arg) => {
-                if (arg.type) {
-                    return arg.type;
-                }
-                if (arg.valueExpression) {
-                    const valueExpressionNode = arg.valueExpression;
-                    return useSpeculativeMode(valueExpressionNode, () => {
-                        return getTypeOfExpression(valueExpressionNode).type;
-                    });
-                }
-                return types_1.AnyType.create();
-            });
         });
         filteredMatchResults = sortOverloadsByBestMatch(filteredMatchResults);
         // If there are no possible arg/param matches among the overloads,
@@ -5239,6 +5295,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             // We didn't find an overload match. Try to expand the next union
             // argument type into individual types and retry with the expanded types.
+            if (!contextFreeArgTypes) {
+                useSpeculativeMode(errorNode, () => {
+                    // Evaluate the types of each argument expression without regard to
+                    // the expectedType. We'll use this to determine whether we need to do
+                    // union expansion.
+                    contextFreeArgTypes = argList.map((arg) => {
+                        if (arg.type) {
+                            return arg.type;
+                        }
+                        if (arg.valueExpression) {
+                            const valueExpressionNode = arg.valueExpression;
+                            return useSpeculativeMode(valueExpressionNode, () => {
+                                return getTypeOfExpression(valueExpressionNode).type;
+                            });
+                        }
+                        return types_1.AnyType.create();
+                    });
+                });
+            }
             expandedArgTypes = expandArgumentUnionTypes(contextFreeArgTypes, expandedArgTypes);
             // Check for combinatoric explosion and break out of loop.
             if (!expandedArgTypes || expandedArgTypes.length > maxOverloadUnionExpansionCount) {
@@ -5637,6 +5712,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, 
                         /* includesTypes */ false);
                     }
+                    // Handle the NewType specially, replacing the normal return type.
+                    if (expandedSubtype.details.builtInName === 'NewType') {
+                        return createNewType(errorNode, argList);
+                    }
                     let effectiveTypeVarContext = typeVarContext;
                     if (!effectiveTypeVarContext) {
                         // If a typeVarContext wasn't provided by the caller, allocate one here.
@@ -5673,10 +5752,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             argumentErrors = true;
                         }
                     }
-                    // Handle the NewType specially, replacing the normal return type.
-                    if (!functionResult.argumentErrors && expandedSubtype.details.builtInName === 'NewType') {
-                        return createNewType(errorNode, argList);
-                    }
                     if (expandedSubtype.details.builtInName === '__import__') {
                         // For the special __import__ type, we'll override the return type to be "Any".
                         // This is required because we don't know what module was imported, and we don't
@@ -6845,7 +6920,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // scope.
         let eliminateUnsolvedInUnions = true;
         let curNode = errorNode;
-        while (true) {
+        while (curNode) {
             const typeVarScopeNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
             if (!typeVarScopeNode) {
                 break;
@@ -6854,7 +6929,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (typeVarContext.hasSolveForScope(typeVarScopeId)) {
                 eliminateUnsolvedInUnions = false;
             }
-            curNode = typeVarScopeNode;
+            curNode = typeVarScopeNode.parent;
         }
         // If the function is returning a callable, don't eliminate unsolved
         // type vars within a union. There are legit uses for unsolved type vars
@@ -7321,21 +7396,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (paramName === 'covariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.variance === 2 /* Contravariant */) {
+                        if (typeVar.details.declaredVariance === 3 /* Contravariant */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
-                            typeVar.details.variance = 1 /* Covariant */;
+                            typeVar.details.declaredVariance = 2 /* Covariant */;
                         }
                     }
                 }
                 else if (paramName === 'contravariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.variance === 1 /* Covariant */) {
+                        if (typeVar.details.declaredVariance === 2 /* Covariant */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
-                            typeVar.details.variance = 2 /* Contravariant */;
+                            typeVar.details.declaredVariance = 3 /* Contravariant */;
                         }
                     }
                 }
@@ -9796,7 +9871,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function transformTypeForTypeAlias(type, name, errorNode) {
+    function transformTypeForTypeAlias(type, name, errorNode, typeParameters) {
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
         }
@@ -9805,17 +9880,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
             return type;
         }
-        // Determine if there are any generic type parameters associated
-        // with this type alias.
-        let typeParameters = [];
-        // Skip this for a simple TypeVar (one that's not part of a union).
-        if (!(0, types_1.isTypeVar)(type) || types_1.TypeBase.isAnnotated(type)) {
-            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(subtype));
-            });
+        if (!typeParameters) {
+            // Determine if there are any generic type parameters associated
+            // with this type alias.
+            typeParameters = [];
+            // Skip this for a simple TypeVar (one that's not part of a union).
+            if (!(0, types_1.isTypeVar)(type) || types_1.TypeBase.isAnnotated(type)) {
+                (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(subtype));
+                });
+            }
+            // Don't include any synthesized type variables.
+            typeParameters = typeParameters.filter((typeVar) => !typeVar.details.isSynthesized);
         }
-        // Don't include any synthesized type variables.
-        typeParameters = typeParameters.filter((typeVar) => !typeVar.details.isSynthesized);
         // Convert all type variables to instances.
         typeParameters = typeParameters.map((typeVar) => {
             if (types_1.TypeBase.isInstance(typeVar)) {
@@ -10016,7 +10093,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (!rightHandType) {
                 // Determine whether there is a declared type.
-                const declaredType = getDeclaredTypeForExpression(node.leftExpression, { method: 'set' });
+                const declaredType = getDeclaredTypeForExpression(node.leftExpression, {
+                    method: 'set',
+                });
                 let typeAliasNameNode;
                 let isSpeculativeTypeAlias = false;
                 if (isDeclaredTypeAlias(node.leftExpression)) {
@@ -10122,6 +10201,62 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* allowAssignmentToFinalVar */ true, expectedTypeDiagAddendum);
         writeTypeCache(node, rightHandType, 0 /* None */, isIncomplete);
     }
+    // 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.
+    function getTypeOfTypeAlias(node) {
+        const cachedType = readTypeCache(node.name, 0 /* None */);
+        if (cachedType) {
+            return cachedType;
+        }
+        // Synthesize a type variable that represents the type alias while we're
+        // evaluating it. This allows us to handle recursive definitions.
+        const typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${node.name.value}`);
+        typeAliasTypeVar.details.isSynthesized = true;
+        typeAliasTypeVar.details.recursiveTypeAliasName = node.name.value;
+        const scopeId = getScopeIdForNode(node.name);
+        typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
+        typeAliasTypeVar.scopeId = scopeId;
+        // Write the type to the type cache. It will be replaced below.
+        writeTypeCache(node.name, typeAliasTypeVar, /* flags */ undefined, /* isIncomplete */ false);
+        // Set a partial type to handle recursive (self-referential) type aliases.
+        const scope = ScopeUtils.getScopeForNode(node);
+        const typeAliasSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(node.name.value);
+        const typeAliasDecl = AnalyzerNodeInfo.getDeclaration(node);
+        if (typeAliasDecl && typeAliasSymbol) {
+            setSymbolResolutionPartialType(typeAliasSymbol.symbol, typeAliasDecl, typeAliasTypeVar);
+        }
+        let typeParameters = [];
+        if (node.typeParameters) {
+            typeParameters = evaluateTypeParameterList(node.typeParameters);
+            typeAliasTypeVar.details.recursiveTypeParameters = typeParameters;
+        }
+        const aliasTypeResult = getTypeOfExpressionExpectingType(node.expression);
+        let isIncomplete = false;
+        let aliasType = aliasTypeResult.type;
+        if (aliasTypeResult.isIncomplete) {
+            isIncomplete = true;
+        }
+        // Clear the temporary type we wrote above.
+        deleteTypeCacheEntry(node.name);
+        aliasType = transformTypeForTypeAlias(aliasType, node.name, node.expression, typeParameters);
+        if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
+                name: node.name.value,
+            }), node.expression);
+            aliasType = types_1.UnknownType.create();
+        }
+        // Set the resulting type to the boundType of the original type alias
+        // to support recursive type aliases.
+        typeAliasTypeVar.details.boundType = aliasType;
+        if (typeAliasTypeVar.details.illegalRecursionDetected) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveIndirect().format({
+                name: node.name.value,
+            }), node.name);
+        }
+        writeTypeCache(node.name, aliasType, 0 /* None */, isIncomplete);
+        return aliasType;
+    }
     function evaluateTypesForAugmentedAssignment(node) {
         if (readTypeCache(node, 0 /* None */)) {
             return;
@@ -10187,7 +10322,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node.name, classType, /* flags */ undefined, /* isIncomplete */ false);
         // Keep a list of unique type parameters that are used in the
         // base class arguments.
-        const typeParameters = [];
+        let typeParameters = [];
+        if (node.typeParameters) {
+            typeParameters = evaluateTypeParameterList(node.typeParameters).map((t) => types_1.TypeVarType.cloneAsInstance(t));
+        }
         // If the class derives from "Generic" directly, it will provide
         // all of the type parameters in the specified order.
         let genericTypeParameters;
@@ -10308,12 +10446,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
                 if ((0, types_1.isInstantiableClass)(argType)) {
                     if (types_1.ClassType.isBuiltIn(argType, 'Generic')) {
-                        if (!genericTypeParameters) {
-                            if (protocolTypeParameters) {
-                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateGenericAndProtocolBase(), arg.valueExpression);
+                        // 'Generic' is implicitly added if type parameter syntax is used.
+                        if (node.typeParameters) {
+                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericBaseClassNotAllowed(), arg.valueExpression);
+                        }
+                        else {
+                            if (!genericTypeParameters) {
+                                if (protocolTypeParameters) {
+                                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateGenericAndProtocolBase(), arg.valueExpression);
+                                }
+                                genericTypeParameters = [];
+                                (0, typeUtils_1.addTypeVarsToListIfUnique)(genericTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
                             }
-                            genericTypeParameters = [];
-                            (0, typeUtils_1.addTypeVarsToListIfUnique)(genericTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
                         }
                     }
                     else if (types_1.ClassType.isBuiltIn(argType, 'Protocol') &&
@@ -10325,6 +10469,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                             protocolTypeParameters = [];
                             (0, typeUtils_1.addTypeVarsToListIfUnique)(protocolTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
+                            if (node.typeParameters && protocolTypeParameters.length > 0) {
+                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolBaseClassWithTypeArgs(), arg.valueExpression);
+                                protocolTypeParameters = [];
+                            }
                         }
                     }
                 }
@@ -10387,10 +10535,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If genericTypeParameters or protocolTypeParameters are provided,
         // make sure that typeParameters is a proper subset.
         genericTypeParameters = genericTypeParameters !== null && genericTypeParameters !== void 0 ? genericTypeParameters : protocolTypeParameters;
-        if (genericTypeParameters) {
+        if (genericTypeParameters && !node.typeParameters) {
             verifyGenericTypeParameters(node.name, typeParameters, genericTypeParameters);
         }
-        classType.details.typeParameters = genericTypeParameters || typeParameters;
+        classType.details.typeParameters = genericTypeParameters !== null && genericTypeParameters !== void 0 ? genericTypeParameters : typeParameters;
+        // Determine if one or more type parameters is autovariance.
+        if (classType.details.typeParameters.some((param) => param.details.declaredVariance === 0 /* Auto */ && param.computedVariance === undefined)) {
+            classType.details.requiresVarianceInference = true;
+        }
         // Make sure there's at most one variadic type parameter.
         const variadics = classType.details.typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
         if (variadics.length > 1) {
@@ -10420,7 +10572,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const initMethod = classType.details.fields.get('__init__');
             if (initMethod) {
                 const initDecls = initMethod.getTypedDeclarations();
-                if (initDecls.length === 1 && initDecls[0].type === 3 /* Function */) {
+                if (initDecls.length === 1 && initDecls[0].type === 5 /* Function */) {
                     const initDeclNode = initDecls[0].node;
                     const initParams = initDeclNode.parameters;
                     if (initParams.length > 1 &&
@@ -10583,6 +10735,79 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { classType, decoratedType };
     }
+    function inferTypeParameterVarianceForClass(classType) {
+        if (!classType.details.requiresVarianceInference) {
+            return;
+        }
+        if (!objectType || !(0, types_1.isClassInstance)(objectType)) {
+            return;
+        }
+        // Replace all of the type parameters with invariant TypeVars.
+        const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
+        const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
+        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', '', 0, 0, undefined, undefined);
+        updatedTypeParams.forEach((param, paramIndex) => {
+            // Skip variadics and ParamSpecs.
+            if (param.details.isVariadic || param.details.isParamSpec) {
+                return;
+            }
+            // Skip type variables without auto-variance.
+            if (param.details.declaredVariance !== 0 /* Auto */) {
+                return;
+            }
+            // Replace all type arguments with a dummy type except for the
+            // TypeVar of interest, which is replaced with an object instance.
+            const srcTypeArgs = updatedTypeParams.map((p, i) => {
+                if (p.details.isVariadic) {
+                    return p;
+                }
+                return i === paramIndex ? objectType : dummyTypeObject;
+            });
+            // Replace all type arguments with a dummy type except for the
+            // TypeVar of interest, which is replaced with itself.
+            const destTypeArgs = updatedTypeParams.map((p, i) => {
+                return i === paramIndex || p.details.isVariadic ? p : dummyTypeObject;
+            });
+            const srcType = types_1.ClassType.cloneForSpecialization(updatedClassType, srcTypeArgs, 
+            /* isTypeArgumentExplicit */ true);
+            const destType = types_1.ClassType.cloneForSpecialization(updatedClassType, destTypeArgs, 
+            /* isTypeArgumentExplicit */ true);
+            const isDestSubtypeOfSrc = assignClassToSelf(srcType, destType);
+            let inferredVariance;
+            if (isDestSubtypeOfSrc) {
+                inferredVariance = 2 /* Covariant */;
+            }
+            else {
+                const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType);
+                if (isSrcSubtypeOfDest) {
+                    inferredVariance = 3 /* Contravariant */;
+                }
+                else {
+                    inferredVariance = 1 /* Invariant */;
+                }
+            }
+            // We assume here that we don't need to clone the type var object
+            // because it was already cloned when it was associated with this
+            // class scope.
+            classType.details.typeParameters[paramIndex].computedVariance = inferredVariance;
+        });
+        // Note that variance inference is complete.
+        classType.details.requiresVarianceInference = false;
+    }
+    function evaluateTypeParameterList(node) {
+        const paramTypes = [];
+        node.parameters.forEach((param) => {
+            const paramSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(param.name);
+            (0, debug_1.assert)(paramSymbol);
+            const typeOfParam = getDeclaredTypeOfSymbol(paramSymbol, param.name);
+            if (!typeOfParam || !(0, types_1.isTypeVar)(typeOfParam)) {
+                return;
+            }
+            writeTypeCache(param.name, typeOfParam, 0 /* None */, /* isIncomplete */ false);
+            paramTypes.push(typeOfParam);
+        });
+        return paramTypes;
+    }
     function computeEffectiveMetaclass(classType, errorNode) {
         let effectiveMetaclass = classType.details.declaredMetaclass;
         let reportedMetaclassConflict = false;
@@ -10908,6 +11133,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }), node.functionAnnotationComment);
             }
         }
+        if (node.typeParameters) {
+            evaluateTypeParameterList(node.typeParameters);
+        }
         const markParamAccessed = (param) => {
             if (param.name) {
                 const symbolWithScope = lookUpSymbolRecursive(param.name, param.name.value, /* honorCodeFlow */ false);
@@ -11216,7 +11444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const baseClassMemberInfo = (0, typeUtils_1.lookUpClassMember)(containingClassType, methodName, 1 /* SkipOriginalClass */);
             if (baseClassMemberInfo) {
                 const memberDecls = baseClassMemberInfo.symbol.getDeclarations();
-                if (memberDecls.length === 1 && memberDecls[0].type === 3 /* Function */) {
+                if (memberDecls.length === 1 && memberDecls[0].type === 5 /* Function */) {
                     const baseClassMethodNode = memberDecls[0].node;
                     // Does the signature match exactly with the exception of annotations?
                     if (baseClassMethodNode.parameters.length === functionNode.parameters.length &&
@@ -11493,14 +11721,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // to recursion if there is a large number (1000's) of overloads.
                 for (let i = 0; i < declIndex; i++) {
                     const decl = decls[i];
-                    if (decl.type === 3 /* Function */) {
+                    if (decl.type === 5 /* Function */) {
                         getTypeOfFunction(decl.node);
                     }
                 }
                 const overloadedTypes = [];
                 // Look at the previous declaration's type.
                 const prevDecl = decls[declIndex - 1];
-                if (prevDecl.type === 3 /* Function */) {
+                if (prevDecl.type === 5 /* Function */) {
                     const prevDeclDeclTypeInfo = getTypeOfFunction(prevDecl.node);
                     if (prevDeclDeclTypeInfo) {
                         if ((0, types_1.isFunction)(prevDeclDeclTypeInfo.decoratedType)) {
@@ -12050,19 +12278,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // case, we want to choose the last declaration.
         const filteredDecls = symbolWithScope.symbol
             .getDeclarations()
-            .filter((decl) => ParseTreeUtils.isNodeContainedWithin(node, decl.node) && decl.type === 6 /* Alias */);
+            .filter((decl) => ParseTreeUtils.isNodeContainedWithin(node, decl.node) && decl.type === 8 /* Alias */);
         let aliasDecl = filteredDecls.length > 0 ? filteredDecls[filteredDecls.length - 1] : undefined;
         // If we didn't find an exact match, look for any alias associated with
         // this symbol. In cases where we have multiple ImportAs nodes that share
         // the same first-part name (e.g. "import asyncio" and "import asyncio.tasks"),
         // we may not find the declaration associated with this node.
         if (!aliasDecl) {
-            aliasDecl = symbolWithScope.symbol.getDeclarations().find((decl) => decl.type === 6 /* Alias */);
+            aliasDecl = symbolWithScope.symbol.getDeclarations().find((decl) => decl.type === 8 /* Alias */);
         }
         if (!aliasDecl) {
             return undefined;
         }
-        (0, debug_1.assert)(aliasDecl.type === 6 /* Alias */);
+        (0, debug_1.assert)(aliasDecl.type === 8 /* Alias */);
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // Try to resolve the alias while honoring external visibility.
         const resolvedAliasInfo = resolveAliasDeclarationWithInfo(aliasDecl, 
@@ -12099,7 +12327,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // expression or statement that contains it. This contextual evaluation
     // allows for bidirectional type evaluation.
     function evaluateTypesForExpressionInContext(node) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         let lastContextualExpression = node;
         let curNode = node;
         function isContextual(node) {
@@ -12168,6 +12396,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 getTypeOfClass(node.parent);
                 return;
             }
+            else if (node.parent.nodeType === 77 /* TypeAlias */ && node.parent.name === node) {
+                getTypeOfTypeAlias(node.parent);
+                return;
+            }
             else if (node.parent.nodeType === 29 /* Global */ ||
                 node.parent.nodeType === 39 /* Nonlocal */) {
                 // For global and nonlocal statements, allow forward references so
@@ -12206,15 +12438,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             verifyDeleteExpression(lastContextualExpression);
             return;
         }
+        // If this is the name node within a type parameter list, see if it's a type alias
+        // definition. If so, we need to evaluate the type alias contextually.
+        if (parent.nodeType === 75 /* TypeParameter */ && lastContextualExpression === parent.name) {
+            if (((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 76 /* TypeParameterList */ &&
+                ((_b = parent.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 77 /* TypeAlias */) {
+                getTypeOfTypeAlias(parent.parent.parent);
+                return;
+            }
+        }
+        if (parent.nodeType === 75 /* TypeParameter */) {
+            getTypeOfExpression(parent.name);
+            return;
+        }
+        if (parent.nodeType === 77 /* TypeAlias */) {
+            getTypeOfTypeAlias(parent);
+            return;
+        }
         if (parent.nodeType === 5 /* AugmentedAssignment */) {
             evaluateTypesForAugmentedAssignment(parent);
             return;
         }
         if (parent.nodeType === 13 /* Decorator */) {
-            if (((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 10 /* Class */) {
+            if (((_c = parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
                 getTypeOfClass(parent.parent);
             }
-            else if (((_b = parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 28 /* Function */) {
+            else if (((_d = parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 28 /* Function */) {
                 getTypeOfFunction(parent.parent);
             }
             return;
@@ -12265,7 +12514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return;
         }
         // A class argument must be evaluated in the context of the class declaration.
-        if (parent.nodeType === 1 /* Argument */ && ((_c = parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
+        if (parent.nodeType === 1 /* Argument */ && ((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 10 /* Class */) {
             getTypeOfClass(parent.parent);
             return;
         }
@@ -12361,6 +12610,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     break;
                 }
+                case 77 /* TypeAlias */: {
+                    getTypeOfTypeAlias(curNode);
+                    return;
+                }
                 case 4 /* AssignmentExpression */: {
                     getTypeOfExpression(curNode);
                     return;
@@ -12887,10 +13140,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (symbolWithScope && honorCodeFlow && scopeTypeHonorsCodeFlow) {
             // Filter the declarations based on flow reachability.
             const reachableDecls = symbolWithScope.symbol.getDeclarations().filter((decl) => {
-                if (decl.type !== 6 /* Alias */ && decl.type !== 0 /* Intrinsic */) {
+                if (decl.type !== 8 /* Alias */ && decl.type !== 0 /* Intrinsic */) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
                     const usageScope = ParseTreeUtils.getExecutionScopeNode(node);
-                    const declNode = decl.type === 4 /* Class */ || decl.type === 3 /* Function */
+                    const declNode = decl.type === 6 /* Class */ ||
+                        decl.type === 5 /* Function */ ||
+                        decl.type === 4 /* TypeAlias */
                         ? decl.node.name
                         : decl.node;
                     const declScope = ParseTreeUtils.getExecutionScopeNode(declNode);
@@ -13008,7 +13263,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isFunction)(type)) {
             if (type.details.declaration) {
                 const functionDecl = type.details.declaration;
-                if (functionDecl.type === 3 /* Function */) {
+                if (functionDecl.type === 5 /* Function */) {
                     const functionNode = functionDecl.node;
                     const functionScope = AnalyzerNodeInfo.getScope(functionNode);
                     if (functionScope) {
@@ -13072,7 +13327,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // 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.
                     const declsForThisImport = symbolInScope.symbol.getDeclarations().filter((decl) => {
-                        return decl.type === 6 /* Alias */ && decl.node === node.parent;
+                        return decl.type === 8 /* Alias */ && decl.node === node.parent;
                     });
                     (0, collectionUtils_1.appendArray)(declarations, (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsForThisImport));
                 }
@@ -13081,7 +13336,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else if (node.parent &&
             node.parent.nodeType === 35 /* MemberAccess */ &&
             node === node.parent.memberName) {
-            let baseType = getType(node.parent.leftExpression);
+            let baseType = getTypeOfExpression(node.parent.leftExpression, 2 /* DoNotSpecialize */).type;
             if (baseType) {
                 baseType = makeTopLevelTypeVarsConcrete(baseType);
                 const memberName = node.parent.memberName.value;
@@ -13196,9 +13451,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Determine if this node is within a quoted type annotation.
             const isWithinTypeAnnotation = ParseTreeUtils.isWithinTypeAnnotation(node, !(0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node)));
             const allowForwardReferences = isWithinTypeAnnotation || fileInfo.isStubFile;
-            const symbolWithScope = lookUpSymbolRecursive(node, node.value, !allowForwardReferences, isWithinTypeAnnotation);
-            if (symbolWithScope) {
-                (0, collectionUtils_1.appendArray)(declarations, symbolWithScope.symbol.getDeclarations());
+            let symbol;
+            const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
+            if (typeParamSymbol) {
+                symbol = typeParamSymbol;
+            }
+            else {
+                const symbolWithScope = lookUpSymbolRecursive(node, node.value, !allowForwardReferences, isWithinTypeAnnotation);
+                symbol = symbolWithScope === null || symbolWithScope === void 0 ? void 0 : symbolWithScope.symbol;
+            }
+            if (symbol) {
+                (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
             }
         }
         return declarations;
@@ -13244,17 +13507,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return types_1.UnknownType.create();
             }
-            case 4 /* Class */: {
+            case 6 /* Class */: {
                 const classTypeInfo = getTypeOfClass(declaration.node);
                 return classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.decoratedType;
             }
-            case 5 /* SpecialBuiltInClass */: {
+            case 7 /* SpecialBuiltInClass */: {
                 return getTypeOfAnnotation(declaration.node.typeAnnotation);
             }
-            case 3 /* Function */: {
+            case 5 /* Function */: {
                 const functionTypeInfo = getTypeOfFunction(declaration.node);
                 return functionTypeInfo === null || functionTypeInfo === void 0 ? void 0 : functionTypeInfo.decoratedType;
             }
+            case 4 /* TypeAlias */: {
+                return getTypeOfTypeAlias(declaration.node);
+            }
             case 2 /* Parameter */: {
                 let typeAnnotationNode = declaration.node.typeAnnotation || declaration.node.typeAnnotationComment;
                 // If there wasn't an annotation, see if the parent function
@@ -13276,6 +13542,62 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return undefined;
             }
+            case 3 /* TypeParameter */: {
+                let typeVar = types_1.TypeVarType.createInstantiable(declaration.node.name.value);
+                if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
+                    typeVar.details.isVariadic = true;
+                }
+                else if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
+                    typeVar.details.isParamSpec = true;
+                }
+                if (declaration.node.boundExpression) {
+                    if (declaration.node.boundExpression.nodeType === 52 /* Tuple */) {
+                        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);
+                            }
+                            return (0, typeUtils_1.convertToInstance)(constraintType);
+                        });
+                        if (constraints.length < 2) {
+                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(declaration.node.boundExpression).diagnosticRuleSet
+                                .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarSingleConstraint(), declaration.node.boundExpression);
+                        }
+                        else if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
+                            typeVar.details.constraints = constraints;
+                        }
+                    }
+                    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);
+                        }
+                        if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
+                            typeVar.details.boundType = (0, typeUtils_1.convertToInstance)(boundType);
+                        }
+                    }
+                }
+                typeVar.details.isTypeParamSyntax = true;
+                // Associate the type variable with the owning scope.
+                const scopeNode = ParseTreeUtils.getTypeVarScopeNode(declaration.node);
+                if (scopeNode) {
+                    let scopeType;
+                    if (scopeNode.nodeType === 10 /* Class */) {
+                        scopeType = 0 /* Class */;
+                        // Set the variance to "auto" for class-scoped TypeVars.
+                        typeVar.details.declaredVariance = 0 /* Auto */;
+                    }
+                    else if (scopeNode.nodeType === 28 /* Function */) {
+                        scopeType = 1 /* Function */;
+                    }
+                    else {
+                        (0, debug_1.assert)(scopeNode.nodeType === 77 /* TypeAlias */);
+                        scopeType = 2 /* TypeAlias */;
+                    }
+                    typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, getScopeIdForNode(scopeNode.nodeType === 77 /* TypeAlias */ ? scopeNode.name : scopeNode), scopeNode.name.value, scopeType);
+                }
+                return typeVar;
+            }
             case 1 /* Variable */: {
                 const typeAnnotationNode = declaration.typeAnnotationNode;
                 if (typeAnnotationNode) {
@@ -13313,7 +13635,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return undefined;
             }
-            case 6 /* Alias */: {
+            case 8 /* Alias */: {
                 return undefined;
             }
         }
@@ -13360,11 +13682,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the resolved declaration is still an alias, the alias
         // is pointing at a module, and we need to synthesize a
         // module type.
-        if (resolvedDecl.type === 6 /* Alias */) {
+        if (resolvedDecl.type === 8 /* Alias */) {
             // Build a module type that corresponds to the declaration and
             // its associated loader actions.
             let moduleName = resolvedDecl.moduleName;
-            if (decl.type === 6 /* Alias */) {
+            if (decl.type === 8 /* Alias */) {
                 if (decl.symbolName) {
                     moduleName += '.' + decl.symbolName;
                 }
@@ -13615,7 +13937,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 considerDecl = false;
             }
             if (usageNode !== undefined) {
-                if (decl.type !== 6 /* Alias */) {
+                if (decl.type !== 8 /* Alias */) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
                     const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
                     const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
@@ -13728,9 +14050,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // reachable from the usage node (if specified). This can happen in
         // cases where a property symbol is redefined to add a setter, deleter,
         // etc.
-        if (typedDecls.length > 1 && usageNode) {
+        if (usageNode && typedDecls.length > 1) {
             const filteredTypedDecls = typedDecls.filter((decl) => {
-                if (decl.type !== 6 /* Alias */) {
+                if (decl.type !== 8 /* Alias */) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
                     const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
                     const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
@@ -13742,9 +14064,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return true;
             });
-            if (filteredTypedDecls.length > 0) {
-                typedDecls = filteredTypedDecls;
+            if (filteredTypedDecls.length === 0) {
+                return types_1.UnboundType.create();
             }
+            typedDecls = filteredTypedDecls;
         }
         // Start with the last decl. If that's already being resolved,
         // use the next-to-last decl, etc. This can happen when resolving
@@ -13770,7 +14093,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // in the type cache. This exception is required to handle the
                         // circular dependency between the "type" and "object" classes in
                         // builtins.pyi (since "object" is a "type" and "type" is an "object").
-                        if (popSymbolResolution(symbol) || decl.type === 4 /* Class */) {
+                        if (popSymbolResolution(symbol) || decl.type === 6 /* Class */) {
                             return type;
                         }
                     }
@@ -14121,6 +14444,63 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }));
         return false;
     }
+    // This function is used to validate or infer the variance of type
+    // parameters within a class.
+    function assignClassToSelf(destType, srcType, recursionCount = 0) {
+        (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
+        (0, debug_1.assert)(destType.details.typeParameters.length > 0);
+        const diag = new diagnostic_1.DiagnosticAddendum();
+        const typeVarContext = new typeVarContext_1.TypeVarContext();
+        let isAssignable = true;
+        destType.details.fields.forEach((symbol, name) => {
+            if (isAssignable && symbol.isClassMember() && !symbol.isIgnoredForProtocolMatch()) {
+                const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
+                (0, debug_1.assert)(memberInfo !== undefined);
+                let destMemberType = getDeclaredTypeOfSymbol(symbol);
+                if (destMemberType) {
+                    const srcMemberType = getTypeOfMember(memberInfo);
+                    destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
+                    // Properties require special processing.
+                    if ((0, types_1.isClassInstance)(destMemberType) &&
+                        types_1.ClassType.isPropertyClass(destMemberType) &&
+                        (0, types_1.isClassInstance)(srcMemberType) &&
+                        types_1.ClassType.isPropertyClass(srcMemberType)) {
+                        if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
+                        /* selfTypeVarContext */ undefined, recursionCount)) {
+                            isAssignable = false;
+                        }
+                    }
+                    else {
+                        const primaryDecl = symbol.getDeclarations()[0];
+                        // Class and instance variables that are mutable need to
+                        // enforce invariance.
+                        const flags = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !primaryDecl.isFinal
+                            ? 1 /* EnforceInvariance */
+                            : 0 /* Default */;
+                        if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
+                        /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+                            isAssignable = false;
+                        }
+                    }
+                }
+            }
+        });
+        // Now handle generic base classes.
+        destType.details.baseClasses.forEach((baseClass) => {
+            if ((0, types_1.isInstantiableClass)(baseClass) &&
+                !types_1.ClassType.isBuiltIn(baseClass, 'object') &&
+                !types_1.ClassType.isBuiltIn(baseClass, 'Protocol') &&
+                !types_1.ClassType.isBuiltIn(baseClass, 'Generic') &&
+                baseClass.details.typeParameters.length > 0) {
+                const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
+                const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
+                if (!assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, recursionCount)) {
+                    isAssignable = false;
+                }
+            }
+        });
+        return isAssignable;
+    }
     function assignTupleTypeArgs(destType, srcType, diag, typeVarContext, flags, recursionCount) {
         var _a, _b;
         const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
@@ -14214,6 +14594,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let curSrcType = srcType;
         let curTypeVarContext = destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType));
         let effectiveFlags = flags;
+        inferTypeParameterVarianceForClass(destType);
         // If we're using a private typeVarContext, don't skip solving type vars.
         if (!destTypeVarContext) {
             effectiveFlags &= ~8 /* SkipSolveTypeVars */;
@@ -14294,6 +14675,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function verifyTypeArgumentsAssignable(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b, _c;
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
+        inferTypeParameterVarianceForClass(destType);
         const destTypeParams = types_1.ClassType.getTypeParameters(destType);
         let destTypeArgs;
         let srcTypeArgs;
@@ -14320,21 +14702,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const destTypeArg = destArgIndex >= 0 ? destTypeArgs[destArgIndex] : types_1.UnknownType.create();
                 const destTypeParam = destArgIndex < destTypeParams.length ? destTypeParams[destArgIndex] : undefined;
                 const assignmentDiag = new diagnostic_1.DiagnosticAddendum();
-                if (!destTypeParam || destTypeParam.details.variance === 1 /* Covariant */) {
+                if (!destTypeParam || types_1.TypeVarType.getVariance(destTypeParam) === 2 /* Covariant */) {
                     if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
-                        if (destTypeParam) {
-                            if (diag) {
+                        if (diag) {
+                            if (destTypeParam) {
                                 const childDiag = diag.createAddendum();
                                 childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarIsCovariant().format({
                                     name: types_1.TypeVarType.getReadableName(destTypeParam),
                                 }));
                                 childDiag.addAddendum(assignmentDiag);
                             }
+                            else {
+                                diag.addAddendum(assignmentDiag);
+                            }
                         }
                         return false;
                     }
                 }
-                else if (destTypeParam.details.variance === 2 /* Contravariant */) {
+                else if (types_1.TypeVarType.getVariance(destTypeParam) === 3 /* Contravariant */) {
                     if (!assignType(srcTypeArg, destTypeArg, assignmentDiag, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         if (diag) {
                             const childDiag = diag.createAddendum();
@@ -14992,10 +15377,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (isSubtypeSubsumed || subtypeIndex === innerSubtypeIndex || (0, types_1.isAnyOrUnknown)(innerSubtype)) {
                         return;
                     }
-                    if (assignType(innerSubtype, concreteSubtype, 
-                    /* diag */ undefined, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+                    if (isProperSubtype(innerSubtype, concreteSubtype, recursionCount)) {
                         isSubtypeSubsumed = true;
                     }
                 });
@@ -15015,6 +15397,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return true;
     }
+    // Determines whether the srcType is a subtype of destType but the converse
+    // is not true. It's important that we check both directions to avoid
+    // matches for types like `tuple[Any]` and `tuple[int]` from being considered
+    // proper subtypes of each other.
+    function isProperSubtype(destType, srcType, recursionCount) {
+        return (assignType(destType, srcType, 
+        /* diag */ undefined, 
+        /* destTypeVarContext */ undefined, 
+        /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount) &&
+            !assignType(srcType, destType, 
+            /* diag */ undefined, 
+            /* destTypeVarContext */ undefined, 
+            /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount));
+    }
     function assignToUnionType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         // If we need to enforce invariance, the source needs to be compatible
         // with all subtypes in the dest, unless those subtypes are subclasses
@@ -16281,7 +16677,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getAbstractMethods(classType) {
         const symbolTable = new Map();
-        classType.details.mro.forEach((mroClass) => {
+        types_1.ClassType.getReverseMro(classType).forEach((mroClass) => {
             if ((0, types_1.isInstantiableClass)(mroClass)) {
                 // See if this class is introducing a new abstract method that has not been
                 // introduced previously or if it is overriding an abstract method with
@@ -16290,10 +16686,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // We do a quick-and-dirty evaluation of methods based on
                     // decorators to determine which ones are abstract. This allows
                     // us to avoid evaluating the full function types.
-                    if (symbol.isClassMember()) {
+                    // Handle named tuple fields as though they are class members here.
+                    // We model them as instance variables, but they're actually implemented
+                    // using class variable descriptors, and these overwrite a class variable
+                    // abstract method.
+                    if (symbol.isClassMember() || symbol.isNamedTupleMemberMember()) {
                         let isAbstract;
                         const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-                        if (decl && decl.type === 3 /* Function */) {
+                        if (decl && decl.type === 5 /* Function */) {
                             const functionFlags = getFunctionFlagsFromDecorators(decl.node, true);
                             isAbstract = !!(functionFlags & 8 /* AbstractMethod */);
                         }
@@ -16304,14 +16704,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // "overrides" it with an instance variable.
                             isAbstract = false;
                         }
-                        if (!symbolTable.has(symbolName)) {
+                        if (isAbstract) {
                             symbolTable.set(symbolName, {
                                 symbol,
                                 symbolName,
-                                isAbstract,
                                 classType: mroClass,
                             });
                         }
+                        else {
+                            symbolTable.delete(symbolName);
+                        }
                     }
                 });
             }
@@ -16319,9 +16721,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Create a final list of methods that are abstract.
         const methodList = [];
         symbolTable.forEach((method) => {
-            if (method.isAbstract) {
-                methodList.push(method);
-            }
+            methodList.push(method);
         });
         return methodList;
     }
@@ -16569,6 +16969,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignType,
         validateOverrideMethod,
         assignTypeToExpression,
+        assignClassToSelf,
         getTypedDictClassType,
         getTupleClassType,
         getObjectType,
@@ -16576,6 +16977,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypingType,
         verifyTypeArgumentsAssignable,
         inferReturnTypeIfNecessary,
+        inferTypeParameterVarianceForClass,
         addError,
         addWarning,
         addInformation,