@zzzen/pyright-internal 1.2.0-beta → 1.2.0-dev.20220710

package/dist/analyzer/typeEvaluator.js

@@ -660,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--;
@@ -920,7 +915,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const argList = [
             {
                 argumentCategory: 0 /* Simple */,
-                type: functionOrClassType,
+                typeResult: { type: functionOrClassType },
             },
         ];
         const returnType = validateCallArguments(node.expression, argList, decoratorTypeResult, 
@@ -1235,7 +1230,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         function addFakeArg() {
             argList.push({
                 argumentCategory: previousCategory,
-                type: types_1.UnknownType.create(),
+                typeResult: { type: types_1.UnknownType.create() },
                 active: true,
             });
         }
@@ -1368,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 */) {
@@ -1386,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);
@@ -2540,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;
@@ -2556,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)) {
@@ -2660,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
@@ -2748,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);
                 }
             }
@@ -2773,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 */);
@@ -2866,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;
@@ -2917,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,
@@ -3530,25 +3569,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             {
                                 // Provide "obj" argument.
                                 argumentCategory: 0 /* Simple */,
-                                type: types_1.ClassType.isClassProperty(lookupClass)
-                                    ? baseTypeClass
-                                    : isAccessedThroughObject
-                                        ? bindToType || types_1.ClassType.cloneAsInstance(baseTypeClass)
-                                        : types_1.NoneType.createInstance(),
+                                typeResult: {
+                                    type: types_1.ClassType.isClassProperty(lookupClass)
+                                        ? baseTypeClass
+                                        : isAccessedThroughObject
+                                            ? bindToType || types_1.ClassType.cloneAsInstance(baseTypeClass)
+                                            : types_1.NoneType.createInstance(),
+                                },
                             },
                         ];
                         if (usage.method === 'get') {
                             // Provide "objtype" argument.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                type: baseTypeClass,
+                                typeResult: { type: baseTypeClass },
                             });
                         }
                         else if (usage.method === 'set') {
                             // Provide "value" argument.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                type: (_a = usage.setType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(),
+                                typeResult: { type: (_a = usage.setType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create() },
                             });
                         }
                         if (types_1.ClassType.isPropertyClass(lookupClass) &&
@@ -3782,55 +3823,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Applies the __getattr__, __setattr__ or __delattr__ method if present.
     function applyAttributeAccessOverride(classType, errorNode, usage, memberName) {
-        var _a, _b, _c, _d;
-        if (usage.method === 'get') {
+        var _a, _b, _c;
+        const getAttributeAccessMember = (name) => {
+            var _a;
             // See if the class has a "__getattribute__" or "__getattr__" method.
             // If so, arbitrary members are supported.
-            let getAttrType = (_a = getTypeOfClassMember(errorNode, classType, '__getattribute__', { method: 'get' }, 
+            return (_a = getTypeOfClassMember(errorNode, classType, name, { method: 'get' }, 
             /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
-            if (!getAttrType) {
-                getAttrType = (_b = getTypeOfClassMember(errorNode, classType, '__getattr__', { method: 'get' }, 
-                /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _b === void 0 ? void 0 : _b.type;
-            }
-            // If it's an overload, it might be based on the member name. Create
-            // a literal str type based on the member name and find the best overload.
-            if (getAttrType && (0, types_1.isOverloadedFunction)(getAttrType)) {
-                let nameLiteralType = types_1.AnyType.create();
-                if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
-                    nameLiteralType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName);
-                }
-                getAttrType = getBestOverloadForArguments(errorNode, getAttrType, [
-                    {
-                        argumentCategory: 0 /* Simple */,
-                        type: types_1.AnyType.create(),
-                    },
-                    {
-                        argumentCategory: 0 /* Simple */,
-                        type: nameLiteralType,
-                    },
-                ]);
-            }
-            if (getAttrType && (0, types_1.isFunction)(getAttrType)) {
-                return getFunctionEffectiveReturnType(getAttrType);
-            }
+        };
+        let accessMemberType;
+        if (usage.method === 'get') {
+            accessMemberType = (_a = getAttributeAccessMember('__getattribute__')) !== null && _a !== void 0 ? _a : getAttributeAccessMember('__getattr__');
         }
         else if (usage.method === 'set') {
-            const setAttrType = (_c = getTypeOfClassMember(errorNode, classType, '__setattr__', { method: 'get' }, 
-            /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _c === void 0 ? void 0 : _c.type;
-            if (setAttrType) {
-                // The type doesn't matter for a set usage. We just need
-                // to return a defined type.
-                return types_1.AnyType.create();
-            }
+            accessMemberType = getAttributeAccessMember('__setattr__');
         }
         else {
             (0, debug_1.assert)(usage.method === 'del');
-            const delAttrType = (_d = getTypeOfClassMember(errorNode, classType, '__detattr__', { method: 'get' }, 
-            /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _d === void 0 ? void 0 : _d.type;
-            if (delAttrType) {
-                // The type doesn't matter for a delete usage. We just need
-                // to return a defined type.
-                return types_1.AnyType.create();
+            accessMemberType = getAttributeAccessMember('__delattr__');
+        }
+        if (accessMemberType) {
+            let nameLiteralType = types_1.AnyType.create();
+            if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
+                nameLiteralType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName);
+            }
+            const argList = [
+                {
+                    // Provide "self" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: types_1.ClassType.cloneAsInstance(classType) },
+                },
+                {
+                    // Provide "name" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: nameLiteralType },
+                },
+            ];
+            if (usage.method === 'set') {
+                argList.push({
+                    // Provide "value" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: (_b = usage.setType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create() },
+                });
+            }
+            if ((0, types_1.isFunction)(accessMemberType) || (0, types_1.isOverloadedFunction)(accessMemberType)) {
+                const boundMethodType = bindFunctionToClassOrObject(classType, accessMemberType, classType, errorNode);
+                if (boundMethodType && ((0, types_1.isFunction)(boundMethodType) || (0, types_1.isOverloadedFunction)(boundMethodType))) {
+                    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(boundMethodType));
+                    const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
+                    /* skipUnknownArgCheck */ true);
+                    return (_c = callResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
+                }
             }
         }
         return undefined;
@@ -4130,7 +4173,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;
@@ -4369,9 +4412,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const keywordArgs = node.items.filter((item) => item.argumentCategory === 0 /* Simple */ && !!item.name);
         const unpackedDictArgs = node.items.filter((item) => item.argumentCategory === 2 /* UnpackedDictionary */);
         let positionalIndexType;
+        let isPositionalIndexTypeIncomplete = false;
         if (positionalArgs.length === 1 && unpackedListArgs.length === 0 && !node.trailingComma) {
             // Handle the common case where there is a single positional argument.
-            positionalIndexType = getTypeOfExpression(positionalArgs[0].valueExpression).type;
+            const typeResult = getTypeOfExpression(positionalArgs[0].valueExpression);
+            positionalIndexType = typeResult.type;
+            if (typeResult.isIncomplete) {
+                isPositionalIndexTypeIncomplete = true;
+            }
         }
         else if (positionalArgs.length === 0 && unpackedListArgs.length === 0) {
             // Handle the case where there are no positionals provided but there are keywords.
@@ -4384,10 +4432,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Package up all of the positionals into a tuple.
             const tupleEntries = [];
             positionalArgs.forEach((arg) => {
-                tupleEntries.push(getTypeOfExpression(arg.valueExpression).type);
+                const typeResult = getTypeOfExpression(arg.valueExpression);
+                tupleEntries.push(typeResult.type);
+                if (typeResult.isIncomplete) {
+                    isPositionalIndexTypeIncomplete = true;
+                }
             });
             unpackedListArgs.forEach((arg) => {
-                const exprType = getTypeOfExpression(arg.valueExpression).type;
+                const typeResult = getTypeOfExpression(arg.valueExpression);
+                const exprType = typeResult.type;
+                if (typeResult.isIncomplete) {
+                    isPositionalIndexTypeIncomplete = true;
+                }
                 const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg) || types_1.UnknownType.create();
                 tupleEntries.push(iterableType);
             });
@@ -4396,7 +4452,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let argList = [
             {
                 argumentCategory: 0 /* Simple */,
-                type: positionalIndexType,
+                typeResult: { type: positionalIndexType, isIncomplete: isPositionalIndexTypeIncomplete },
             },
         ];
         if (usage.method === 'set') {
@@ -4408,7 +4464,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             argList.push({
                 argumentCategory: 0 /* Simple */,
-                type: setType,
+                typeResult: { type: setType, isIncomplete: isPositionalIndexTypeIncomplete },
             });
         }
         keywordArgs.forEach((arg) => {
@@ -4430,29 +4486,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Speculatively attempt the call. We may need to replace the index
         // type with 'int', and we don't want to emit errors before we know
         // which type to use.
-        useSpeculativeMode(node, () => {
-            callResult = validateCallArguments(node, argList, { type: itemMethodType });
-            if (callResult.argumentErrors) {
-                // If the object supports "__index__" magic method, convert
-                // the index it to an int and try again.
-                if ((0, types_1.isClassInstance)(positionalIndexType) && keywordArgs.length === 0 && unpackedDictArgs.length === 0) {
-                    const altArgList = [...argList];
-                    altArgList[0] = { ...altArgList[0] };
-                    const indexMethod = getTypeOfObjectMember(node, positionalIndexType, '__index__');
-                    if (indexMethod) {
-                        const intType = getBuiltInObject(node, 'int');
-                        if ((0, types_1.isClassInstance)(intType)) {
-                            altArgList[0].type = intType;
+        if (keywordArgs.length === 0 && unpackedDictArgs.length === 0 && positionalArgs.length === 1) {
+            useSpeculativeMode(node, () => {
+                callResult = validateCallArguments(node, argList, { type: itemMethodType });
+                if (callResult.argumentErrors) {
+                    // If the object supports "__index__" magic method, convert
+                    // the index to an int and try again.
+                    if ((0, types_1.isClassInstance)(positionalIndexType)) {
+                        const altArgList = [...argList];
+                        altArgList[0] = { ...altArgList[0] };
+                        const indexMethod = getTypeOfObjectMember(node, positionalIndexType, '__index__');
+                        if (indexMethod) {
+                            const intType = getBuiltInObject(node, 'int');
+                            if ((0, types_1.isClassInstance)(intType)) {
+                                altArgList[0].typeResult = { type: intType };
+                            }
+                        }
+                        callResult = validateCallArguments(node, altArgList, { type: itemMethodType });
+                        // We were successful, so replace the arg list.
+                        if (!callResult.argumentErrors) {
+                            argList = altArgList;
                         }
-                    }
-                    callResult = validateCallArguments(node, altArgList, { type: itemMethodType });
-                    // We were successful, so replace the arg list.
-                    if (!callResult.argumentErrors) {
-                        argList = altArgList;
                     }
                 }
-            }
-        });
+            });
+        }
         callResult = validateCallArguments(node, argList, { type: itemMethodType });
         return {
             node,
@@ -5262,8 +5320,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // 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.typeResult) {
+                            return arg.typeResult.type;
                         }
                         if (arg.valueExpression) {
                             const valueExpressionNode = arg.valueExpression;
@@ -5673,6 +5731,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.
@@ -5709,10 +5771,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
@@ -6165,7 +6223,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const funcArg = listElementType
                     ? {
                         argumentCategory: 0 /* Simple */,
-                        type: listElementType,
+                        typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete },
                     }
                     : undefined;
                 if (funcArg && argTypeResult.isIncomplete) {
@@ -6330,7 +6388,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                         argument: {
                                             argumentCategory: 0 /* Simple */,
-                                            type: entry.valueType,
+                                            typeResult: { type: entry.valueType },
                                         },
                                         errorNode: argList[argIndex].valueExpression || errorNode,
                                         paramName: name,
@@ -6345,7 +6403,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: {
                                         argumentCategory: 0 /* Simple */,
-                                        type: entry.valueType,
+                                        typeResult: { type: entry.valueType },
                                     },
                                     errorNode: argList[argIndex].valueExpression || errorNode,
                                     paramName: name,
@@ -6535,7 +6593,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: {
                                 argumentCategory: 0 /* Simple */,
-                                type: unpackedDictionaryArgType,
+                                typeResult: { type: unpackedDictionaryArgType },
                             },
                             errorNode: (_b = (_a = argList.find((arg) => arg.argumentCategory === 2 /* UnpackedDictionary */)) === null || _a === void 0 ? void 0 : _a.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                             paramName: param.name,
@@ -6582,7 +6640,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: true,
                                     argument: {
                                         argumentCategory: 0 /* Simple */,
-                                        type: defaultArgType,
+                                        typeResult: { type: defaultArgType },
                                     },
                                     errorNode: errorNode,
                                     paramName: param.name,
@@ -6636,7 +6694,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramCategory: 1 /* VarArgList */,
                             paramType,
                             requiresTypeVarMatching: true,
-                            argument: { argumentCategory: 0 /* Simple */, type: specializedTuple },
+                            argument: {
+                                argumentCategory: 0 /* Simple */,
+                                typeResult: { type: specializedTuple },
+                            },
                             errorNode,
                             paramName: paramDetails.params[paramDetails.argsIndex].param.name,
                             isParamNameSynthesized: paramDetails.params[paramDetails.argsIndex].param.isNameSynthesized,
@@ -6881,7 +6942,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // scope.
         let eliminateUnsolvedInUnions = true;
         let curNode = errorNode;
-        while (true) {
+        while (curNode) {
             const typeVarScopeNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
             if (!typeVarScopeNode) {
                 break;
@@ -6890,7 +6951,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
@@ -7138,7 +7199,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argType) {
                 argType = argParam.argType;
             }
-            else if (argParam.expectingType && !argParam.argument.type && argParam.argument.valueExpression) {
+            else if (argParam.expectingType && !argParam.argument.typeResult && argParam.argument.valueExpression) {
                 const argTypeResult = getTypeOfExpression(argParam.argument.valueExpression, 8 /* EvaluateStringLiteralAsType */ |
                     32 /* ParamSpecDisallowed */ |
                     128 /* TypeVarTupleDisallowed */);
@@ -7317,7 +7378,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { isCompatible, argType, isTypeIncomplete, condition };
     }
     function createTypeVarType(errorNode, argList) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         let typeVarName = '';
         let firstConstraintArg;
         if (argList.length === 0) {
@@ -7346,7 +7407,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                     }
                     else {
-                        const argType = (_a = argList[i].type) !== null && _a !== void 0 ? _a : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
+                        const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
                         /* allowFinal */ undefined, 
                         /* allowRequired */ undefined).type;
                         if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
@@ -7357,26 +7418,26 @@ 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 === 4 /* Contravariant */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
-                            typeVar.details.variance = 1 /* Covariant */;
+                            typeVar.details.declaredVariance = 3 /* Covariant */;
                         }
                     }
                 }
                 else if (paramName === 'contravariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.variance === 1 /* Covariant */) {
+                        if (typeVar.details.declaredVariance === 3 /* Covariant */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
-                            typeVar.details.variance = 2 /* Contravariant */;
+                            typeVar.details.declaredVariance = 4 /* Contravariant */;
                         }
                     }
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
+                    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);
                 }
                 paramNameMap.set(paramName, paramName);
             }
@@ -7385,7 +7446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
-                    const argType = (_c = argList[i].type) !== null && _c !== void 0 ? _c : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
+                    const argType = (_e = (_d = argList[i].typeResult) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
                     /* allowFinal */ undefined, 
                     /* allowRequired */ undefined).type;
                     if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
@@ -7880,7 +7941,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // incomplete because we may be evaluating types within a loop,
         // so the literal values may change each time.
         const isLiteralMathAllowed = !ParseTreeUtils.isWithinLoop(node);
-        let type = validateBinaryOperation(node.operator, leftType, rightType, node, expectedType, diag, isLiteralMathAllowed);
+        let type = validateBinaryOperation(node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, expectedType, diag, isLiteralMathAllowed);
         if (!diag.isEmpty() || !type) {
             if (!isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -7966,14 +8027,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
                     }
                     const magicMethodName = operatorMap[node.operator][0];
-                    let returnType = getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [rightSubtypeUnexpanded], magicMethodName, node, expectedType);
+                    let returnType = getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     if (!returnType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                         // Try with the expanded left type.
-                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [rightSubtypeUnexpanded], magicMethodName, node, expectedType);
+                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     }
                     if (!returnType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                         // Try with the expanded left and right type.
-                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [rightSubtypeExpanded], magicMethodName, node, expectedType);
+                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     }
                     if (!returnType) {
                         // If the LHS class didn't support the magic method for augmented
@@ -7986,7 +8047,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             !rightTypeResult.isIncomplete &&
                             (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) <
                                 maxLiteralMathSubtypeCount;
-                        returnType = validateBinaryOperation(binaryOperator, leftSubtypeUnexpanded, rightSubtypeUnexpanded, node, expectedType, diag, isLiteralMathAllowed);
+                        returnType = validateBinaryOperation(binaryOperator, { type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }, { type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }, node, expectedType, diag, isLiteralMathAllowed);
                     }
                     return returnType;
                 });
@@ -8009,7 +8070,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignTypeToExpression(node.destExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression);
         return typeResult;
     }
-    function validateBinaryOperation(operator, leftType, rightType, errorNode, expectedType, diag, isLiteralMathAllowed) {
+    function validateBinaryOperation(operator, leftTypeResult, rightTypeResult, errorNode, expectedType, diag, isLiteralMathAllowed) {
+        const leftType = leftTypeResult.type;
+        const rightType = rightTypeResult.type;
         let type;
         let concreteLeftType = makeTopLevelTypeVarsConcrete(leftType);
         if (booleanOperatorMap[operator] !== undefined) {
@@ -8059,7 +8122,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if ((0, types_1.isAnyOrUnknown)(leftSubtype) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
                             return (0, typeUtils_1.preserveUnknown)(leftSubtype, rightSubtypeExpanded);
                         }
-                        let returnType = getTypeOfMagicMethodReturn(rightSubtypeExpanded, [leftSubtype], '__contains__', errorNode, 
+                        let returnType = getTypeOfMagicMethodReturn(rightSubtypeExpanded, [{ type: leftSubtype, isIncomplete: leftTypeResult.isIncomplete }], '__contains__', errorNode, 
                         /* expectedType */ undefined);
                         if (!returnType) {
                             // If __contains__ was not supported, fall back
@@ -8216,26 +8279,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             ]));
                         }
                         const magicMethodName = binaryOperatorMap[operator][0];
-                        let resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeUnexpanded), [rightSubtypeUnexpanded], magicMethodName, errorNode, expectedType);
+                        let resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeUnexpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                             // Try the expanded left type.
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [rightSubtypeUnexpanded], magicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         }
                         if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                             // Try the expanded left and right type.
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [rightSubtypeExpanded], magicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         }
                         if (!resultType) {
                             // Try the alternate form (swapping right and left).
                             const altMagicMethodName = binaryOperatorMap[operator][1];
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeUnexpanded), [leftSubtypeUnexpanded], altMagicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeUnexpanded), [{ type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, expectedType);
                             if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                                 // Try the expanded right type.
-                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [leftSubtypeUnexpanded], altMagicMethodName, errorNode, expectedType);
+                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [
+                                    {
+                                        type: leftSubtypeUnexpanded,
+                                        isIncomplete: leftTypeResult.isIncomplete,
+                                    },
+                                ], altMagicMethodName, errorNode, expectedType);
                             }
                             if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                                 // Try the expanded right and left type.
-                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [leftSubtypeExpanded], altMagicMethodName, errorNode, expectedType);
+                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [{ type: leftSubtypeExpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, expectedType);
                             }
                         }
                         if (!resultType) {
@@ -8283,7 +8351,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const functionArgs = args.map((arg) => {
                     return {
                         argumentCategory: 0 /* Simple */,
-                        type: arg,
+                        typeResult: arg,
                     };
                 });
                 let callResult;
@@ -9079,15 +9147,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, node, isIncomplete };
     }
     function getTypeOfSlice(node) {
-        // Evaluate the expressions to report errors and record symbol references.
-        if (node.startValue) {
-            getTypeOfExpression(node.startValue);
-        }
-        if (node.endValue) {
-            getTypeOfExpression(node.endValue);
-        }
-        if (node.stepValue) {
-            getTypeOfExpression(node.stepValue);
+        // Evaluate the expressions to report errors and record symbol
+        // references. We can skip this if we're executing speculatively.
+        if (!speculativeTypeTracker.isSpeculative(node)) {
+            if (node.startValue) {
+                getTypeOfExpression(node.startValue);
+            }
+            if (node.endValue) {
+                getTypeOfExpression(node.endValue);
+            }
+            if (node.stepValue) {
+                getTypeOfExpression(node.stepValue);
+            }
         }
         return { type: getBuiltInObject(node, 'slice'), node };
     }
@@ -9832,7 +9903,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;
         }
@@ -9841,17 +9912,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)) {
@@ -10052,7 +10125,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)) {
@@ -10158,6 +10233,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;
@@ -10223,7 +10354,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;
@@ -10344,12 +10478,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') &&
@@ -10361,6 +10501,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 = [];
+                            }
                         }
                     }
                 }
@@ -10423,10 +10567,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) {
@@ -10456,7 +10604,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 &&
@@ -10506,6 +10654,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const effectiveMetaclass = computeEffectiveMetaclass(classType, node.name);
+        // Clear the "partially constructed" flag.
+        classType.details.flags &= ~131072 /* PartiallyEvaluated */;
         // Now determine the decorated type of the class.
         let decoratedType = classType;
         let foundUnknown = false;
@@ -10542,8 +10692,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
             (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, classType, initSubclassArgs);
         }
-        // Clear the "partially constructed" flag.
-        classType.details.flags &= ~131072 /* PartiallyEvaluated */;
         // Run any class hooks that depend on this class.
         runClassTypeHooks(classType);
         // Synthesize TypedDict methods.
@@ -10619,6 +10767,87 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { classType, decoratedType };
     }
+    function inferTypeParameterVarianceForClass(classType) {
+        if (!classType.details.requiresVarianceInference) {
+            return;
+        }
+        if (!objectType || !(0, types_1.isClassInstance)(objectType)) {
+            return;
+        }
+        // Presumptively mark the variance inference as complete. This
+        // prevents potential recursion.
+        classType.details.requiresVarianceInference = false;
+        // Presumptively mark the computed variance to "in progress". We'll
+        // replace this below once the variance has been inferred.
+        classType.details.typeParameters.forEach((param) => {
+            if (param.details.declaredVariance === 0 /* Auto */) {
+                param.computedVariance = 1 /* Unknown */;
+            }
+        });
+        // 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 = 3 /* Covariant */;
+            }
+            else {
+                const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType);
+                if (isSrcSubtypeOfDest) {
+                    inferredVariance = 4 /* Contravariant */;
+                }
+                else {
+                    inferredVariance = 2 /* 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;
+        });
+    }
+    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;
@@ -10944,6 +11173,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);
@@ -11252,7 +11484,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 &&
@@ -11529,14 +11761,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)) {
@@ -12086,19 +12318,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, 
@@ -12135,7 +12367,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) {
@@ -12204,6 +12436,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
@@ -12242,15 +12478,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;
@@ -12301,7 +12554,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;
         }
@@ -12397,6 +12650,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     break;
                 }
+                case 77 /* TypeAlias */: {
+                    getTypeOfTypeAlias(curNode);
+                    return;
+                }
                 case 4 /* AssignmentExpression */: {
                     getTypeOfExpression(curNode);
                     return;
@@ -12844,8 +13101,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return specializedClass;
     }
     function getTypeOfArgument(arg) {
-        if (arg.type) {
-            return { type: arg.type };
+        if (arg.typeResult) {
+            return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
         if (!arg.valueExpression) {
             // We shouldn't ever get here, but just in case.
@@ -12860,8 +13117,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // and therefore follows the normal rules of types (e.g. they
     // can be forward-declared in stubs, etc.).
     function getTypeOfArgumentExpectingType(arg) {
-        if (arg.type) {
-            return { type: arg.type };
+        if (arg.typeResult) {
+            return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
         // If there was no defined type provided, there should always
         // be a value expression from which we can retrieve the type.
@@ -12923,10 +13180,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);
@@ -13044,7 +13303,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) {
@@ -13108,7 +13367,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));
                 }
@@ -13232,9 +13491,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;
@@ -13280,17 +13547,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
@@ -13312,6 +13582,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) {
@@ -13349,7 +13675,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return undefined;
             }
-            case 6 /* Alias */: {
+            case 8 /* Alias */: {
                 return undefined;
             }
         }
@@ -13396,11 +13722,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;
                 }
@@ -13651,7 +13977,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);
@@ -13764,9 +14090,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);
@@ -13778,9 +14104,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
@@ -13806,7 +14133,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;
                         }
                     }
@@ -14157,6 +14484,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 : [])];
@@ -14250,6 +14634,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 */;
@@ -14330,6 +14715,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;
@@ -14356,7 +14742,7 @@ 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) === 3 /* Covariant */) {
                     if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         if (diag) {
                             if (destTypeParam) {
@@ -14373,7 +14759,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return false;
                     }
                 }
-                else if (destTypeParam.details.variance === 2 /* Contravariant */) {
+                else if (types_1.TypeVarType.getVariance(destTypeParam) === 4 /* Contravariant */) {
                     if (!assignType(srcTypeArg, destTypeArg, assignmentDiag, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         if (diag) {
                             const childDiag = diag.createAddendum();
@@ -15056,6 +15442,17 @@ 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) {
+        // Shortcut the check if either type is Any or Unknown.
+        if ((0, types_1.isAnyOrUnknown)(destType) || (0, types_1.isAnyOrUnknown)(srcType)) {
+            return true;
+        }
+        // Shortcut the check if either type is a class whose hierarchy contains an unknown type.
+        if ((0, types_1.isClass)(destType) && destType.details.mro.some((mro) => (0, types_1.isAnyOrUnknown)(mro))) {
+            return true;
+        }
+        if ((0, types_1.isClass)(srcType) && srcType.details.mro.some((mro) => (0, types_1.isAnyOrUnknown)(mro))) {
+            return true;
+        }
         return (assignType(destType, srcType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
@@ -16347,7 +16744,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     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 */);
                         }
@@ -16623,6 +17020,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignType,
         validateOverrideMethod,
         assignTypeToExpression,
+        assignClassToSelf,
         getTypedDictClassType,
         getTupleClassType,
         getObjectType,
@@ -16630,6 +17028,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypingType,
         verifyTypeArgumentsAssignable,
         inferReturnTypeIfNecessary,
+        inferTypeParameterVarianceForClass,
         addError,
         addWarning,
         addInformation,