@zzzen/pyright-internal 1.2.0-dev.20240721 → 1.2.0-dev.20240804

package/dist/analyzer/checker.js

@@ -50,6 +50,7 @@ const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const constraintTracker_1 = require("./constraintTracker");
 const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
 const declaration_1 = require("./declaration");
@@ -69,12 +70,12 @@ const sourceMapper_1 = require("./sourceMapper");
 const staticExpressions_1 = require("./staticExpressions");
 const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
 const symbolUtils_1 = require("./symbolUtils");
+const typedDicts_1 = require("./typedDicts");
 const typeEvaluator_1 = require("./typeEvaluator");
+const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const typeGuards_1 = require("./typeGuards");
-const typeUtils_1 = require("./typeUtils");
-const typeVarContext_1 = require("./typeVarContext");
-const typedDicts_1 = require("./typedDicts");
 const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
 // When enabled, this debug flag causes the code complexity of
 // functions to be emitted.
 const isPrintCodeComplexityEnabled = false;
@@ -90,7 +91,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // have their own scopes.
         this._scopedNodes = [];
         // A list of all visited type parameter lists.
-        this._typeParameterLists = [];
+        this._typeParamLists = [];
         this._moduleNode = parseResults.parseTree;
         this._fileInfo = AnalyzerNodeInfo.getFileInfo(this._moduleNode);
     }
@@ -218,43 +219,44 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // parameters after this need to be flagged as an error.
             let sawParamSpecArgs = false;
             const keywordNames = new Set();
-            const paramDetails = (0, parameterUtils_1.getParameterListDetails)(functionTypeResult.functionType);
+            const paramDetails = (0, parameterUtils_1.getParamListDetails)(functionTypeResult.functionType);
             // Report any unknown or missing parameter types.
             node.d.params.forEach((param, index) => {
                 var _a;
                 if (param.d.name) {
-                    if (param.d.category === 0 /* ParameterCategory.Simple */ && index >= paramDetails.positionOnlyParamCount) {
+                    if (param.d.category === 0 /* ParamCategory.Simple */ && index >= paramDetails.positionOnlyParamCount) {
                         keywordNames.add(param.d.name.d.value);
                     }
                     // Determine whether this is a P.args parameter.
-                    if (param.d.category === 1 /* ParameterCategory.ArgsList */) {
+                    if (param.d.category === 1 /* ParamCategory.ArgsList */) {
                         const annotationExpr = (_a = param.d.annotation) !== null && _a !== void 0 ? _a : param.d.annotationComment;
                         if (annotationExpr &&
                             annotationExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                             annotationExpr.d.member.d.value === 'args') {
                             const baseType = this._evaluator.getType(annotationExpr.d.leftExpr);
-                            if (baseType && (0, types_1.isTypeVar)(baseType) && baseType.shared.isParamSpec) {
+                            if (baseType && (0, types_1.isParamSpec)(baseType)) {
                                 sawParamSpecArgs = true;
                             }
                         }
                     }
-                    else if (param.d.category === 2 /* ParameterCategory.KwargsDict */) {
+                    else if (param.d.category === 2 /* ParamCategory.KwargsDict */) {
                         sawParamSpecArgs = false;
                     }
                 }
-                if (param.d.name && param.d.category === 0 /* ParameterCategory.Simple */ && sawParamSpecArgs) {
+                if (param.d.name && param.d.category === 0 /* ParamCategory.Simple */ && sawParamSpecArgs) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedParamAfterParamSpecArgs().format({ name: param.d.name.d.value }), param.d.name);
                 }
                 // Allow unknown and missing param types if the param is named '_'.
                 if (param.d.name && param.d.name.d.value !== '_') {
-                    const functionTypeParam = functionTypeResult.functionType.shared.parameters.find((p) => { var _a; return p.name === ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value); });
-                    if (functionTypeParam) {
-                        const paramType = functionTypeParam.type;
+                    const paramIndex = functionTypeResult.functionType.shared.parameters.findIndex((p) => { var _a; return p.name === ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value); });
+                    if (paramIndex >= 0) {
+                        const functionTypeParam = functionTypeResult.functionType.shared.parameters[paramIndex];
+                        const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, paramIndex);
                         if (this._fileInfo.diagnosticRuleSet.reportUnknownParameterType !== 'none') {
                             if ((0, types_1.isUnknown)(paramType) ||
                                 ((0, types_1.isTypeVar)(paramType) &&
                                     paramType.shared.isSynthesized &&
-                                    !paramType.shared.isSynthesizedSelf)) {
+                                    !types_1.TypeVarType.isSelf(paramType))) {
                                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.d.name.d.value }), param.d.name);
                             }
                             else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
@@ -273,7 +275,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         else {
                             // See if this is a "self" and "cls" parameter. They are exempt from this rule.
-                            if ((0, types_1.isTypeVar)(paramType) && paramType.shared.isSynthesizedSelf) {
+                            if ((0, types_1.isTypeVar)(paramType) && types_1.TypeVarType.isSelf(paramType)) {
                                 hasAnnotation = true;
                             }
                         }
@@ -286,7 +288,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Verify that an unpacked TypedDict doesn't overlap any keyword parameters.
             if (paramDetails.hasUnpackedTypedDict) {
                 const kwargsIndex = functionTypeResult.functionType.shared.parameters.length - 1;
-                const kwargsType = types_1.FunctionType.getEffectiveParameterType(functionTypeResult.functionType, kwargsIndex);
+                const kwargsType = types_1.FunctionType.getParamType(functionTypeResult.functionType, kwargsIndex);
                 if ((0, types_1.isClass)(kwargsType) && kwargsType.shared.typedDictEntries) {
                     const overlappingEntries = new Set();
                     kwargsType.shared.typedDictEntries.knownItems.forEach((_, name) => {
@@ -302,9 +304,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             // Check for invalid use of ParamSpec P.args and P.kwargs.
-            const paramSpecParams = functionTypeResult.functionType.shared.parameters.filter((param) => {
-                if (types_1.FunctionParam.isTypeDeclared(param) && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
-                    if (param.category !== 0 /* ParameterCategory.Simple */ && param.name && param.type.priv.paramSpecAccess) {
+            const paramSpecParams = functionTypeResult.functionType.shared.parameters.filter((param, index) => {
+                const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, index);
+                if (types_1.FunctionParam.isTypeDeclared(param) && (0, types_1.isTypeVar)(paramType) && (0, types_1.isParamSpec)(paramType)) {
+                    if (param.category !== 0 /* ParamCategory.Simple */ && param.name && paramType.priv.paramSpecAccess) {
                         return true;
                     }
                 }
@@ -342,10 +345,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (functionTypeResult) {
                 const annotationNode = param.d.annotation || param.d.annotationComment;
                 if (annotationNode && index < functionTypeResult.functionType.shared.parameters.length) {
-                    const paramType = functionTypeResult.functionType.shared.parameters[index].type;
+                    const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, index);
                     const exemptMethods = ['__init__', '__new__'];
                     if (containingClassNode &&
                         (0, types_1.isTypeVar)(paramType) &&
+                        paramType.priv.scopeType === 0 /* TypeVarScopeType.Class */ &&
                         paramType.shared.declaredVariance === 3 /* Variance.Covariant */ &&
                         !paramType.shared.isSynthesized &&
                         !exemptMethods.some((name) => name === functionTypeResult.functionType.shared.name)) {
@@ -578,34 +582,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 else {
                     const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
-                    declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
+                    declaredReturnType = this._evaluator.stripTypeGuard(declaredReturnType);
+                    let adjReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
-                    if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, 
-                    /* destTypeVarContext */ new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
+                    if (this._evaluator.assignType(adjReturnType, returnType, diagAddendum)) {
                         returnTypeMatches = true;
                     }
                     else {
                         // See if the declared return type includes one or more constrained TypeVars. If so,
                         // try to narrow these TypeVars to a single type.
-                        const uniqueTypeVars = (0, typeUtils_1.getTypeVarArgumentsRecursive)(declaredReturnType);
-                        if (uniqueTypeVars && uniqueTypeVars.some((typeVar) => typeVar.shared.constraints.length > 0)) {
-                            const typeVarContext = new typeVarContext_1.TypeVarContext();
+                        const uniqueTypeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(declaredReturnType);
+                        if (uniqueTypeVars && uniqueTypeVars.some((typeVar) => types_1.TypeVarType.hasConstraints(typeVar))) {
+                            const constraints = new constraintTracker_1.ConstraintTracker();
                             for (const typeVar of uniqueTypeVars) {
-                                if (typeVar.shared.constraints.length > 0) {
-                                    const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, typeVar);
+                                if (types_1.TypeVarType.hasConstraints(typeVar)) {
+                                    const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, types_1.TypeVarType.cloneAsBound(typeVar));
                                     if (narrowedType) {
-                                        typeVarContext.setTypeVarType(typeVar, narrowedType);
-                                        typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(typeVar));
+                                        constraints.setBounds(typeVar, narrowedType);
                                     }
                                 }
                             }
-                            if (!typeVarContext.isEmpty()) {
-                                const adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
-                                if (this._evaluator.assignType(adjustedReturnType, returnType, diagAddendum, 
-                                /* destTypeVarContext */ undefined, 
-                                /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
+                            if (!constraints.isEmpty()) {
+                                adjReturnType = this._evaluator.solveAndApplyConstraints(declaredReturnType, constraints);
+                                adjReturnType = (0, typeUtils_1.makeTypeVarsBound)(adjReturnType, liveScopes);
+                                if (this._evaluator.assignType(adjReturnType, returnType, diagAddendum)) {
                                     returnTypeMatches = true;
                                 }
                             }
@@ -723,8 +724,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         //   assert (x > 3, "bad value x")
         const type = this._evaluator.getType(node.d.testExpr);
         if (type && (0, types_1.isClassInstance)(type)) {
-            if ((0, typeUtils_1.isTupleClass)(type) && type.priv.tupleTypeArguments) {
-                if (type.priv.tupleTypeArguments.length > 0) {
+            if ((0, typeUtils_1.isTupleClass)(type) && type.priv.tupleTypeArgs) {
+                if (type.priv.tupleTypeArgs.length > 0) {
                     if (!(0, typeUtils_1.isUnboundedTupleClass)(type)) {
                         this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.LocMessage.assertAlwaysTrue(), node.d.testExpr);
                     }
@@ -763,7 +764,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitAugmentedAssignment(node) {
-        this._evaluator.evaluateTypesForStatement(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.destExpr, typeResult);
         return true;
     }
     visitIndex(node) {
@@ -774,15 +776,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (baseType) {
             (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
-                if (!(0, types_1.isClassInstance)(subtype) ||
-                    !(tupleType === null || tupleType === void 0 ? void 0 : tupleType.priv.tupleTypeArguments) ||
-                    (0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
+                if (!(0, types_1.isClassInstance)(subtype) || !(tupleType === null || tupleType === void 0 ? void 0 : tupleType.priv.tupleTypeArgs) || (0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
                     return;
                 }
-                const tupleLength = tupleType.priv.tupleTypeArguments.length;
+                const tupleLength = tupleType.priv.tupleTypeArgs.length;
                 if (node.d.items.length !== 1 ||
                     node.d.trailingComma ||
-                    node.d.items[0].d.argCategory !== 0 /* ArgumentCategory.Simple */ ||
+                    node.d.items[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
                     node.d.items[0].d.name) {
                     return;
                 }
@@ -834,7 +834,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateContainmentTypes(node);
             }
         }
-        this._evaluator.getType(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.leftExpr, typeResult);
         return true;
     }
     visitSlice(node) {
@@ -853,7 +854,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.d.operator === 38 /* OperatorType.Not */) {
             this._validateConditionalIsBool(node.d.expr);
         }
-        this._evaluator.getType(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.expr, typeResult);
         return true;
     }
     visitTernary(node) {
@@ -963,7 +965,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitMemberAccess(node) {
         var _a;
-        const typeResult = this._evaluator.getTypeResult(node);
+        const typeResult = this._evaluator.getTypeResult(node.d.member);
         const type = (_a = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         const leftExprType = this._evaluator.getType(node.d.leftExpr);
         this._reportDeprecatedUseForType(node.d.member, type, leftExprType && (0, types_1.isModule)(leftExprType) && leftExprType.priv.moduleName === 'typing');
@@ -1055,7 +1057,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitTypeParameterList(node) {
-        this._typeParameterLists.push(node);
+        this._typeParamLists.push(node);
         return true;
     }
     visitTypeParameter(node) {
@@ -1071,14 +1073,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             if (typeVarScopeNode.nodeType === 10 /* ParseNodeType.Class */) {
                 const classType = (_c = this._evaluator.getTypeOfClass(typeVarScopeNode)) === null || _c === void 0 ? void 0 : _c.classType;
-                if (classType === null || classType === void 0 ? void 0 : classType.shared.typeParameters.some((param) => param.shared.name === node.d.name.d.value)) {
+                if (classType === null || classType === void 0 ? void 0 : classType.shared.typeParams.some((param) => param.shared.name === node.d.name.d.value)) {
                     foundDuplicate = true;
                     break;
                 }
             }
             else if (typeVarScopeNode.nodeType === 31 /* ParseNodeType.Function */) {
                 const functionType = (_d = this._evaluator.getTypeOfFunction(typeVarScopeNode)) === null || _d === void 0 ? void 0 : _d.functionType;
-                if (functionType === null || functionType === void 0 ? void 0 : functionType.shared.typeParameters.some((param) => param.shared.name === node.d.name.d.value)) {
+                if (functionType === null || functionType === void 0 ? void 0 : functionType.shared.typeParams.some((param) => param.shared.name === node.d.name.d.value)) {
                     foundDuplicate = true;
                     break;
                 }
@@ -1166,6 +1168,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let isTypeBool = true;
         const diag = new diagnostic_1.DiagnosticAddendum();
         this._evaluator.mapSubtypesExpandTypeVars(operandType, /* options */ undefined, (expandedSubtype) => {
+            var _a;
             if ((0, types_1.isAnyOrUnknown)(expandedSubtype)) {
                 return undefined;
             }
@@ -1174,8 +1177,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return undefined;
             }
             // Invoke the __bool__ method on the type.
-            const boolReturnType = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
-            /* inferenceContext */ undefined);
+            const boolReturnType = (_a = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
+            /* inferenceContext */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
             if (!boolReturnType || (0, types_1.isAnyOrUnknown)(boolReturnType)) {
                 return undefined;
             }
@@ -1408,6 +1411,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         isPossiblyTrue = true;
                     }
                 });
+                (0, typeUtils_1.doForEachSubtype)(rightType, (rightSubtype) => {
+                    if (this._evaluator.assignType(leftType, rightSubtype)) {
+                        isPossiblyTrue = true;
+                    }
+                });
                 if (!isPossiblyTrue) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
                         leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
@@ -1467,12 +1475,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isInstantiableClass)(leftType) || ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'type'))) {
             if ((0, types_1.isInstantiableClass)(rightType) ||
                 ((0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, 'type'))) {
-                const genericLeftType = types_1.ClassType.cloneForSpecialization(leftType, 
-                /* typeArguments */ undefined, 
-                /* isTypeArgumentExplicit */ false);
-                const genericRightType = types_1.ClassType.cloneForSpecialization(rightType, 
-                /* typeArguments */ undefined, 
-                /* isTypeArgumentExplicit */ false);
+                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
+                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
                 if (this._evaluator.assignType(genericLeftType, genericRightType) ||
                     this._evaluator.assignType(genericRightType, genericLeftType)) {
                     return true;
@@ -1489,12 +1493,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if ((0, types_1.isClassInstance)(leftType)) {
             if ((0, types_1.isClassInstance)(rightType)) {
-                const genericLeftType = types_1.ClassType.cloneForSpecialization(leftType, 
-                /* typeArguments */ undefined, 
-                /* isTypeArgumentExplicit */ false);
-                const genericRightType = types_1.ClassType.cloneForSpecialization(rightType, 
-                /* typeArguments */ undefined, 
-                /* isTypeArgumentExplicit */ false);
+                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
+                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
                 if (this._evaluator.assignType(genericLeftType, genericRightType) ||
                     this._evaluator.assignType(genericRightType, genericLeftType)) {
                     return true;
@@ -1551,8 +1551,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!generatorType || !(0, types_1.isInstantiableClass)(generatorType)) {
             return;
         }
-        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, [types_1.AnyType.create(), types_1.AnyType.create(), types_1.AnyType.create()], 
-        /* isTypeArgumentExplicit */ true));
+        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(generatorType, [types_1.AnyType.create(), types_1.AnyType.create(), types_1.AnyType.create()]));
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
             const errorMessage = node.d.isAsync
@@ -1593,13 +1592,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             var _a, _b, _c, _d, _e, _f, _g;
             const nameType = this._evaluator.getType(nameNode);
             ``;
-            if (nameType && (0, types_1.isTypeVar)(nameType) && !nameType.shared.isSynthesizedSelf) {
+            if (nameType && (0, types_1.isTypeVar)(nameType) && !types_1.TypeVarType.isSelf(nameType)) {
                 // Does this name refer to a TypeVar that is scoped to this function?
                 if (nameType.priv.scopeId === ParseTreeUtils.getScopeIdForNode(node)) {
                     // We exempt constrained TypeVars, TypeVars that are type arguments of
                     // other types, and ParamSpecs. There are legitimate uses for singleton
                     // instances in these particular cases.
-                    let isExempt = nameType.shared.constraints.length > 0 ||
+                    let isExempt = types_1.TypeVarType.hasConstraints(nameType) ||
                         nameType.shared.isDefaultExplicit ||
                         (exemptBoundTypeVar && subscriptIndex !== undefined) ||
                         (0, types_1.isParamSpec)(nameType);
@@ -1609,7 +1608,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // the TypeVar multiple times.
                         const baseType = this._evaluator.getType(baseExpression);
                         const aliasInfo = (_a = baseType === null || baseType === void 0 ? void 0 : baseType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
-                        if ((aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeParameters) && subscriptIndex < aliasInfo.typeParameters.length) {
+                        if ((aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeParams) && subscriptIndex < aliasInfo.typeParams.length) {
                             isExempt = true;
                         }
                     }
@@ -1704,7 +1703,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Report error for local type variable that appears only once.
             if (usage.nodes.length === 1 && !usage.isExempt) {
                 let altTypeText;
-                if (usage.typeVar.shared.isVariadic) {
+                if ((0, types_1.isTypeVarTuple)(usage.typeVar)) {
                     altTypeText = '"tuple[object, ...]"';
                 }
                 else if (usage.typeVar.shared.boundType) {
@@ -1813,8 +1812,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (prevReturnType &&
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
-                    /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                    /* diag */ undefined, 
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                     const altNode = this._findNodeForOverload(node, prevOverload);
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overloadReturnTypeMismatch().format({
                         name: node.d.name.d.value,
@@ -1845,6 +1845,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return undefined;
     }
     _isOverlappingOverload(functionType, prevOverload, partialOverlap) {
+        var _a, _b, _c;
         // According to precedent, the __get__ method is special-cased and is
         // exempt from overlapping overload checks. It's not clear why this is
         // the case, but for consistency with other type checkers, we'll honor
@@ -1857,24 +1858,49 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (partialOverlap) {
             flags |= 32 /* AssignTypeFlags.PartialOverloadOverlap */;
         }
+        const functionNode = (_a = functionType.shared.declaration) === null || _a === void 0 ? void 0 : _a.node;
+        if (functionNode) {
+            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(functionNode);
+            functionType = (0, typeUtils_1.makeTypeVarsBound)(functionType, liveTypeVars);
+        }
+        // Use the parent node of the declaration in this case so we don't transform
+        // function-local type variables into bound type variables.
+        const prevOverloadNode = (_c = (_b = prevOverload.shared.declaration) === null || _b === void 0 ? void 0 : _b.node) === null || _c === void 0 ? void 0 : _c.parent;
+        if (prevOverloadNode) {
+            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(prevOverloadNode);
+            prevOverload = (0, typeUtils_1.makeTypeVarsBound)(prevOverload, liveTypeVars);
+        }
         return this._evaluator.assignType(functionType, prevOverload, 
-        /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-        /* srcTypeVarContext */ undefined, flags);
-    }
-    _isLegalOverloadImplementation(overload, implementation, diag) {
-        var _a;
-        const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
-        const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
+        /* diag */ undefined, 
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ undefined, flags);
+    }
+    // Determines whether the implementation of an overload is compatible with an
+    // overload signature. To be compatible, the implementation must accept all
+    // of the same arguments as the overload and return a type that is consistent
+    // with the overload's return type.
+    _validateOverloadImplementation(overload, implementation, diag) {
+        var _a, _b, _c;
+        const implConstraints = new constraintTracker_1.ConstraintTracker();
+        const overloadConstraints = new constraintTracker_1.ConstraintTracker();
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadConstraints, implConstraints, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
             2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
             512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
-        const overloadReturnType = (_a = overload.shared.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
-        const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.shared.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
+        let overloadReturnType = (_a = overload.shared.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
+        let implementationReturnType = this._evaluator.solveAndApplyConstraints(implementation.shared.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implConstraints);
+        if ((_c = (_b = implementation.shared.declaration) === null || _b === void 0 ? void 0 : _b.node) === null || _c === void 0 ? void 0 : _c.parent) {
+            // Use the parent node of the implementation to determine which type variables
+            // are live. This will include any class-scoped type variables if this is an
+            // overloaded method.
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(implementation.shared.declaration.node.parent);
+            implementationReturnType = (0, typeUtils_1.makeTypeVarsBound)(implementationReturnType, liveScopeIds);
+            overloadReturnType = (0, typeUtils_1.makeTypeVarsBound)(overloadReturnType, liveScopeIds);
+        }
         const returnDiag = new diagnostic_1.DiagnosticAddendum();
         if (!(0, types_1.isNever)(overloadReturnType) &&
-            !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
+            !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implConstraints, overloadConstraints, 0 /* AssignTypeFlags.Default */)) {
             returnDiag.addMessage(localize_1.LocAddendum.functionReturnTypeMismatch().format({
                 sourceType: this._evaluator.printType(overloadReturnType),
                 destType: this._evaluator.printType(implementationReturnType),
@@ -1891,13 +1917,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // No need to report unreachable more than once since the first time
             // covers all remaining statements in the statement list.
             if (!reportedUnreachable) {
-                if (!this._evaluator.isNodeReachable(statement, prevStatement)) {
+                const reachability = this._evaluator.getNodeReachability(statement, prevStatement);
+                if (reachability !== typeEvaluatorTypes_1.Reachability.Reachable) {
                     // Create a text range that covers the next statement through
                     // the end of the statement list.
                     const start = statement.start;
                     const lastStatement = statements[statements.length - 1];
                     const end = textRange_1.TextRange.getEnd(lastStatement);
-                    this._evaluator.addUnreachableCode(statement, { start, length: end - start });
+                    this._evaluator.addUnreachableCode(statement, reachability, { start, length: end - start });
                     reportedUnreachable = true;
                 }
             }
@@ -2016,8 +2043,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     return;
                 }
-                if (allowTuple && exceptionSubtype.priv.tupleTypeArguments) {
-                    exceptionSubtype.priv.tupleTypeArguments.forEach((typeArg) => {
+                if (allowTuple && exceptionSubtype.priv.tupleTypeArgs) {
+                    exceptionSubtype.priv.tupleTypeArgs.forEach((typeArg) => {
                         this._validateExceptionTypeRecursive(typeArg.type, diag, baseExceptionType, baseExceptionGroupType, 
                         /* allowTuple */ false, isExceptGroup);
                     });
@@ -2066,6 +2093,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._conditionallyReportUnusedSymbol(name, symbol, scope.type, dependentFileInfo);
                     this._reportIncompatibleDeclarations(name, symbol);
                     this._reportMultipleFinalDeclarations(name, symbol, scope.type);
+                    this._reportFinalInLoop(symbol);
                     this._reportMultipleTypeAliasDeclarations(name, symbol);
                     this._reportInvalidOverload(name, symbol);
                 });
@@ -2073,7 +2101,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Report unaccessed type parameters.
         const accessedSymbolSet = this._fileInfo.accessedSymbolSet;
-        for (const paramList of this._typeParameterLists) {
+        for (const paramList of this._typeParamLists) {
             const typeParamScope = AnalyzerNodeInfo.getScope(paramList);
             for (const param of paramList.d.params) {
                 const symbol = typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.get(param.d.name.d.value);
@@ -2165,7 +2193,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
             var _a, _b, _c, _d;
             const diag = new diagnostic_1.DiagnosticAddendum();
-            if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
+            if (!this._validateOverloadImplementation(overload, implementationFunction, diag)) {
                 if (implementationFunction.shared.declaration) {
                     const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadImplementationMismatch().format({
                         name,
@@ -2178,6 +2206,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
+    _reportFinalInLoop(symbol) {
+        if (!this._evaluator.isFinalVariable(symbol)) {
+            return;
+        }
+        const decls = symbol.getDeclarations();
+        if (decls.length === 0) {
+            return;
+        }
+        if (ParseTreeUtils.isWithinLoop(decls[0].node)) {
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalInLoop(), decls[0].node);
+        }
+    }
     _reportMultipleFinalDeclarations(name, symbol, scopeType) {
         if (!this._evaluator.isFinalVariable(symbol)) {
             return;
@@ -2325,7 +2365,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         else if (primaryDecl.type === 6 /* DeclarationType.Class */) {
             primaryDeclInfo = localize_1.LocAddendum.seeClassDeclaration();
         }
-        else if (primaryDecl.type === 2 /* DeclarationType.Parameter */) {
+        else if (primaryDecl.type === 2 /* DeclarationType.Param */) {
             primaryDeclInfo = localize_1.LocAddendum.seeParameterDeclaration();
         }
         else if (primaryDecl.type === 1 /* DeclarationType.Variable */) {
@@ -2348,8 +2388,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         primaryDeclNode = primaryDecl.node;
                     }
                 }
-                else if (primaryDecl.type === 2 /* DeclarationType.Parameter */ ||
-                    primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
+                else if (primaryDecl.type === 2 /* DeclarationType.Param */ ||
+                    primaryDecl.type === 3 /* DeclarationType.TypeParam */) {
                     if (primaryDecl.node.d.name) {
                         primaryDeclNode = primaryDecl.node.d.name;
                     }
@@ -2362,7 +2402,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         for (const otherDecl of otherDecls) {
             if (otherDecl.type === 6 /* DeclarationType.Class */) {
                 let duplicateIsOk = false;
-                if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
+                if (primaryDecl.type === 3 /* DeclarationType.TypeParam */) {
                     // The error will be reported elsewhere if a type parameter is
                     // involved, so don't report it here.
                     duplicateIsOk = true;
@@ -2395,7 +2435,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!isInSameStatementList && primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                     duplicateIsOk = true;
                 }
-                if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
+                if (primaryDecl.type === 3 /* DeclarationType.TypeParam */) {
                     // The error will be reported elsewhere if a type parameter is
                     // involved, so don't report it here.
                     duplicateIsOk = true;
@@ -2407,10 +2447,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     addPrimaryDeclInfo(diag);
                 }
             }
-            else if (otherDecl.type === 2 /* DeclarationType.Parameter */) {
+            else if (otherDecl.type === 2 /* DeclarationType.Param */) {
                 if (otherDecl.node.d.name) {
                     let duplicateIsOk = false;
-                    if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
+                    if (primaryDecl.type === 3 /* DeclarationType.TypeParam */) {
                         // The error will be reported elsewhere if a type parameter is
                         // involved, so don't report it here.
                         duplicateIsOk = true;
@@ -2432,7 +2472,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                             duplicateIsOk = true;
                         }
-                        if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
+                        if (primaryDecl.type === 3 /* DeclarationType.TypeParam */) {
                             // The error will be reported elsewhere if a type parameter is
                             // involved, so don't report it here.
                             duplicateIsOk = true;
@@ -2523,7 +2563,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 break;
             case 4 /* DeclarationType.TypeAlias */:
             case 1 /* DeclarationType.Variable */:
-            case 2 /* DeclarationType.Parameter */:
+            case 2 /* DeclarationType.Param */:
                 if (!isPrivate) {
                     return;
                 }
@@ -2579,8 +2619,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedFunction;
                 message = localize_1.LocMessage.unaccessedFunction().format({ name: nameNode.d.value });
                 break;
-            case 3 /* DeclarationType.TypeParameter */:
-                // Never report a diagnostic for an unused TypeParameter.
+            case 3 /* DeclarationType.TypeParam */:
+                // Never report a diagnostic for an unused TypeParam.
                 diagnosticLevel = 'none';
                 nameNode = decl.node.d.name;
                 break;
@@ -2624,10 +2664,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let isValidType = true;
         const diag = new diagnostic_1.DiagnosticAddendum();
         (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
-            if ((0, types_1.isClassInstance)(arg1Subtype) &&
-                types_1.ClassType.isTupleClass(arg1Subtype) &&
-                arg1Subtype.priv.tupleTypeArguments) {
-                if (arg1Subtype.priv.tupleTypeArguments.some((typeArg) => !this._isTypeSupportedTypeForIsInstance(typeArg.type, isInstanceCheck, diag))) {
+            if ((0, types_1.isClassInstance)(arg1Subtype) && types_1.ClassType.isTupleClass(arg1Subtype) && arg1Subtype.priv.tupleTypeArgs) {
+                if (arg1Subtype.priv.tupleTypeArgs.some((typeArg) => !this._isTypeSupportedTypeForIsInstance(typeArg.type, isInstanceCheck, diag))) {
                     isValidType = false;
                 }
             }
@@ -2653,8 +2691,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
                 if ((0, types_1.isClassInstance)(arg1Subtype) &&
                     types_1.ClassType.isTupleClass(arg1Subtype) &&
-                    arg1Subtype.priv.tupleTypeArguments) {
-                    arg1Subtype.priv.tupleTypeArguments.forEach((typeArg) => {
+                    arg1Subtype.priv.tupleTypeArgs) {
+                    arg1Subtype.priv.tupleTypeArgs.forEach((typeArg) => {
                         this._validateNotDataProtocol(typeArg.type, diag);
                     });
                 }
@@ -2709,8 +2747,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // The isinstance and issubclass call supports a variation where the second
                     // parameter is a tuple of classes.
                     if ((0, typeUtils_1.isTupleClass)(arg1Subtype)) {
-                        if (arg1Subtype.priv.tupleTypeArguments) {
-                            arg1Subtype.priv.tupleTypeArguments.forEach((typeArg) => {
+                        if (arg1Subtype.priv.tupleTypeArgs) {
+                            arg1Subtype.priv.tupleTypeArgs.forEach((typeArg) => {
                                 if ((0, types_1.isInstantiableClass)(typeArg.type)) {
                                     classTypeList.push(typeArg.type);
                                     if (typeArg.type.priv.includeSubclasses) {
@@ -2890,7 +2928,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.LocAddendum.typedDictClassNotAllowed());
                         isSupported = false;
                     }
-                    else if (subtype.priv.isTypeArgumentExplicit && !subtype.priv.includeSubclasses) {
+                    else if (subtype.priv.isTypeArgExplicit && !subtype.priv.includeSubclasses) {
                         // If it's a class, make sure that it has not been given explicit
                         // type arguments. This will result in a TypeError exception.
                         diag.addMessage(localize_1.LocAddendum.genericClassNotAllowed());
@@ -2990,9 +3028,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (errorMessage) {
-            this._reportDeprecatedDiagnostic(node, errorMessage, info.deprecationMessage);
+            this._reportDeprecatedDiagnostic(node, errorMessage, info.deprecatedMessage);
         }
     }
+    _reportDeprecatedUseForOperation(node, typeResult) {
+        const deprecationInfo = typeResult === null || typeResult === void 0 ? void 0 : typeResult.magicMethodDeprecationInfo;
+        if (!deprecationInfo) {
+            return;
+        }
+        this._reportDeprecatedDiagnostic(node, localize_1.LocMessage.deprecatedMethod().format({
+            className: deprecationInfo.className,
+            name: deprecationInfo.methodName,
+        }), deprecationInfo.deprecatedMessage);
+    }
     _reportDeprecatedUseForType(node, type, isImportFromTyping = false) {
         var _a, _b, _c;
         if (!type) {
@@ -3041,7 +3089,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = getDeprecatedMessageForFunction(overload);
                         }
-                        else if ((0, types_1.isInstantiableClass)(type) && overload.shared.name === '__init__') {
+                        else if ((0, types_1.isInstantiableClass)(type) &&
+                            ['__init__', '__new__'].includes(overload.shared.name)) {
                             deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = localize_1.LocMessage.deprecatedConstructor().format({
                                 name: type.shared.name,
@@ -3106,18 +3155,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     ((_c = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) === null || _c === void 0 ? void 0 : _c.fullName) === deprecatedForm.fullName) {
                     if (this._fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(deprecatedForm.version)) {
                         if (!deprecatedForm.typingImportOnly || isImportFromTyping) {
-                            if (this._fileInfo.diagnosticRuleSet.reportDeprecated === 'none') {
-                                this._evaluator.addDeprecated(localize_1.LocMessage.deprecatedType().format({
-                                    version: deprecatedForm.version.toString(),
-                                    replacement: deprecatedForm.replacementText,
-                                }), node);
-                            }
-                            else {
-                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDeprecated, localize_1.LocMessage.deprecatedType().format({
-                                    version: deprecatedForm.version.toString(),
-                                    replacement: deprecatedForm.replacementText,
-                                }), node);
-                            }
+                            this._reportDeprecatedDiagnostic(node, localize_1.LocMessage.deprecatedType().format({
+                                version: deprecatedForm.version.toString(),
+                                replacement: deprecatedForm.replacementText,
+                            }));
                         }
                     }
                 }
@@ -3376,9 +3417,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!returnType) {
             return;
         }
-        if (!(0, types_1.isClassInstance)(returnType) ||
-            !returnType.priv.typeArguments ||
-            returnType.priv.typeArguments.length < 1) {
+        if (!(0, types_1.isClassInstance)(returnType) || !returnType.priv.typeArgs || returnType.priv.typeArgs.length < 1) {
             return;
         }
         const isTypeGuard = types_1.ClassType.isBuiltIn(returnType, 'TypeGuard');
@@ -3399,13 +3438,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeGuardParamCount(), node.d.name);
         }
         if (isTypeIs) {
-            const typeGuardType = returnType.priv.typeArguments[0];
+            const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(functionType);
+            const typeGuardType = (0, typeUtils_1.makeTypeVarsBound)(returnType.priv.typeArgs[0], scopeIds);
             // Determine the type of the first parameter.
             const paramIndex = isMethod && !types_1.FunctionType.isStaticMethod(functionType) ? 1 : 0;
             if (paramIndex >= functionType.shared.parameters.length) {
                 return;
             }
-            const paramType = types_1.FunctionType.getEffectiveParameterType(functionType, paramIndex);
+            const paramType = (0, typeUtils_1.makeTypeVarsBound)(types_1.FunctionType.getParamType(functionType, paramIndex), scopeIds);
             // Verify that the typeGuardType is a narrower type than the paramType.
             if (!this._evaluator.assignType(paramType, typeGuardType)) {
                 const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
@@ -3455,6 +3495,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (declaredReturnType) {
                 this._reportUnknownReturnResult(node, declaredReturnType);
                 this._validateReturnTypeIsNotContravariant(declaredReturnType, returnAnnotation);
+                const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
             }
             // Wrap the declared type in a generator type if the function is a generator.
             if (types_1.FunctionType.isGenerator(functionType)) {
@@ -3609,6 +3651,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (decls[0].type !== 1 /* DeclarationType.Variable */) {
                 return;
             }
+            // Look for an enum attribute annotated with "Final".
+            if (decls[0].isFinal) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.enumMemberTypeAnnotation(), decls[0].node);
+            }
             const declNode = decls[0].node;
             const assignedValueType = symbolType.priv.literalValue.itemType;
             const assignmentNode = ParseTreeUtils.getParentNodeOfType(declNode, 3 /* ParseNodeType.Assignment */);
@@ -3620,21 +3666,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // unpack it. Otherwise, only one argument is passed.
                     const argList = [
                         {
-                            argumentCategory: (0, types_1.isClassInstance)(assignedValueType) && (0, typeUtils_1.isTupleClass)(assignedValueType)
-                                ? 1 /* ArgumentCategory.UnpackedList */
-                                : 0 /* ArgumentCategory.Simple */,
+                            argCategory: (0, types_1.isClassInstance)(assignedValueType) && (0, typeUtils_1.isTupleClass)(assignedValueType)
+                                ? 1 /* ArgCategory.UnpackedList */
+                                : 0 /* ArgCategory.Simple */,
                             typeResult: { type: assignedValueType },
                         },
                     ];
                     if (newMemberTypeResult) {
-                        this._evaluator.validateCallArguments(errorNode, argList, newMemberTypeResult, 
-                        /* typeVarContext */ undefined, 
+                        this._evaluator.validateCallArgs(errorNode, argList, newMemberTypeResult, 
+                        /* constraints */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
                         /* inferenceContext */ undefined);
                     }
                     if (initMemberTypeResult) {
-                        this._evaluator.validateCallArguments(errorNode, argList, initMemberTypeResult, 
-                        /* typeVarContext */ undefined, 
+                        this._evaluator.validateCallArgs(errorNode, argList, initMemberTypeResult, 
+                        /* constraints */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
                         /* inferenceContext */ undefined);
                     }
@@ -3684,7 +3730,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             !postInitType.shared.declaration) {
             return;
         }
-        const paramListDetails = (0, parameterUtils_1.getParameterListDetails)(postInitType);
+        const paramListDetails = (0, parameterUtils_1.getParamListDetails)(postInitType);
         // If there is an *args or **kwargs parameter or a keyword-only separator,
         // don't bother checking.
         if (paramListDetails.argsIndex !== undefined ||
@@ -3693,7 +3739,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Verify that the parameter count matches.
-        const nonDefaultParams = paramListDetails.params.filter((paramInfo) => !paramInfo.param.defaultType);
+        const nonDefaultParams = paramListDetails.params.filter((paramInfo, index) => types_1.FunctionType.getParamDefaultType(postInitType, index) === undefined);
         // We expect to see one param for "self" plus one for each of the InitVars.
         const expectedParamCount = initOnlySymbolMap.size + 1;
         const postInitNode = postInitType.shared.declaration.node;
@@ -3712,7 +3758,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const annotationNode = (_a = paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotation) !== null && _a !== void 0 ? _a : paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotationComment;
             if (types_1.FunctionParam.isTypeDeclared(param) && annotationNode) {
                 const fieldType = (_b = this._evaluator.getDeclaredTypeOfSymbol(symbol)) === null || _b === void 0 ? void 0 : _b.type;
-                const paramType = types_1.FunctionType.getEffectiveParameterType(postInitType, paramListDetails.params[paramIndex].index);
+                const paramType = types_1.FunctionType.getParamType(postInitType, paramListDetails.params[paramIndex].index);
                 const assignTypeDiag = new diagnostic_1.DiagnosticAddendum();
                 if (fieldType && !this._evaluator.assignType(paramType, fieldType, assignTypeDiag)) {
                     const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitType().format({ fieldName }) + assignTypeDiag.getString(), annotationNode);
@@ -3885,7 +3931,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // for an explanation for why this is important to enforce.
     _validateProtocolTypeParamVariance(errorNode, classType) {
         // If this protocol has no TypeVars with specified variance, there's nothing to do here.
-        if (classType.shared.typeParameters.length === 0) {
+        if (classType.shared.typeParams.length === 0) {
             return;
         }
         const objectType = this._evaluator.getBuiltInType(errorNode, 'object');
@@ -3894,9 +3940,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const objectObject = types_1.ClassType.cloneAsInstance(objectType);
         const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
-        classType.shared.typeParameters.forEach((param, paramIndex) => {
-            // Skip variadics and ParamSpecs.
-            if (param.shared.isVariadic || param.shared.isParamSpec) {
+        classType.shared.typeParams.forEach((param, paramIndex) => {
+            // Skip TypeVarTuples and ParamSpecs.
+            if ((0, types_1.isTypeVarTuple)(param) || (0, types_1.isParamSpec)(param)) {
                 return;
             }
             // Skip type variables with auto-variance.
@@ -3905,20 +3951,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // Replace all type arguments with a dummy type except for the
             // TypeVar of interest, which is replaced with an object instance.
-            const srcTypeArgs = classType.shared.typeParameters.map((p, i) => {
-                if (p.shared.isVariadic) {
+            const srcTypeArgs = classType.shared.typeParams.map((p, i) => {
+                if ((0, types_1.isTypeVarTuple)(p)) {
                     return p;
                 }
                 return i === paramIndex ? objectObject : dummyTypeObject;
             });
             // Replace all type arguments with a dummy type except for the
             // TypeVar of interest, which is replaced with itself.
-            const destTypeArgs = classType.shared.typeParameters.map((p, i) => {
-                return i === paramIndex || p.shared.isVariadic ? p : dummyTypeObject;
+            const destTypeArgs = classType.shared.typeParams.map((p, i) => {
+                return i === paramIndex || (0, types_1.isTypeVarTuple)(p) ? p : dummyTypeObject;
             });
-            const srcType = types_1.ClassType.cloneForSpecialization(classType, srcTypeArgs, /* isTypeArgumentExplicit */ true);
-            const destType = types_1.ClassType.cloneForSpecialization(classType, destTypeArgs, 
-            /* isTypeArgumentExplicit */ true);
+            const srcType = types_1.ClassType.specialize(classType, srcTypeArgs);
+            const destType = types_1.ClassType.specialize(classType, destTypeArgs);
             const isDestSubtypeOfSrc = this._evaluator.assignClassToSelf(srcType, destType, 3 /* Variance.Covariant */);
             let expectedVariance;
             if (isDestSubtypeOfSrc) {
@@ -3933,7 +3978,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     expectedVariance = 2 /* Variance.Invariant */;
                 }
             }
-            if (expectedVariance !== classType.shared.typeParameters[paramIndex].shared.declaredVariance) {
+            if (expectedVariance !== classType.shared.typeParams[paramIndex].shared.declaredVariance) {
                 let message;
                 if (expectedVariance === 3 /* Variance.Covariant */) {
                     message = localize_1.LocMessage.protocolVarianceCovariant().format({
@@ -4036,22 +4081,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         // If either of the functions has a default parameter signature
         // (* args: Any, ** kwargs: Any), don't proceed with the check.
-        if (types_1.FunctionType.hasDefaultParameters(initMemberType) || types_1.FunctionType.hasDefaultParameters(newMemberType)) {
+        if (types_1.FunctionType.hasDefaultParams(initMemberType) || types_1.FunctionType.hasDefaultParams(newMemberType)) {
             return;
         }
-        // We'll set the "SkipArgsKwargs" flag for pragmatic reasons since __new__
-        // often has an *args and/or **kwargs. We'll also set the ParamSpecValue
-        // because we don't care about the return type for this check.
-        initMemberType = types_1.FunctionType.cloneWithNewFlags(initMemberType, initMemberType.shared.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
-        newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.shared.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
-        /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
             const initDecl = initMemberType.shared.declaration;
             const newDecl = newMemberType.shared.declaration;
@@ -4098,16 +4138,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         for (const baseClass of filteredBaseClasses) {
-            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
+            const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(baseClass);
             for (const baseClassMroClass of baseClass.shared.mro) {
                 // There's no need to check for conflicts if this class isn't generic.
-                if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.shared.typeParameters.length > 0) {
-                    const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, typeVarContext);
+                if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.shared.typeParams.length > 0) {
+                    const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, solution);
                     // Find the corresponding class in the derived class's MRO list.
                     const matchingMroClass = classType.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, specializedBaseClassMroClass));
                     if (matchingMroClass && (0, types_1.isInstantiableClass)(matchingMroClass)) {
-                        const matchingMroObject = types_1.ClassType.cloneAsInstance(matchingMroClass);
-                        const baseClassMroObject = types_1.ClassType.cloneAsInstance(specializedBaseClassMroClass);
+                        const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(classType);
+                        const matchingMroObject = (0, typeUtils_1.makeTypeVarsBound)(types_1.ClassType.cloneAsInstance(matchingMroClass), scopeIds);
+                        const baseClassMroObject = (0, typeUtils_1.makeTypeVarsBound)(types_1.ClassType.cloneAsInstance(specializedBaseClassMroClass), scopeIds);
                         if (!this._evaluator.assignType(matchingMroObject, baseClassMroObject)) {
                             const diag = new diagnostic_1.DiagnosticAddendum();
                             const baseClassObject = (0, typeUtils_1.convertToInstance)(baseClass);
@@ -4292,8 +4333,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                     diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
                         classType: childClassType.shared.name,
                         name: memberName,
@@ -4459,9 +4500,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             const baseTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, baseClass, 
             /* allowNarrowed */ false);
-            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
+            const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(baseClass);
             const baseExtraItemsType = baseTypedDictEntries.extraItems
-                ? (0, typeUtils_1.applySolvedTypeVars)(baseTypedDictEntries.extraItems.valueType, typeVarContext)
+                ? (0, typeUtils_1.applySolvedTypeVars)(baseTypedDictEntries.extraItems.valueType, solution)
                 : types_1.UnknownType.create();
             for (const [name, entry] of typedDictEntries.knownItems) {
                 const baseEntry = baseTypedDictEntries.knownItems.get(name);
@@ -4473,8 +4514,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     else if (!this._evaluator.assignType(baseExtraItemsType, entry.valueType, 
                     /* diag */ undefined, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
                         ? 1 /* AssignTypeFlags.EnforceInvariance */
                         : 0 /* AssignTypeFlags.Default */)) {
                         diag.addMessage(localize_1.LocAddendum.typedDictClosedExtraTypeMismatch().format({
@@ -4492,8 +4533,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (typedDictEntries.extraItems && baseTypedDictEntries.extraItems) {
                 if (!this._evaluator.assignType(baseExtraItemsType, typedDictEntries.extraItems.valueType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
                     ? 1 /* AssignTypeFlags.EnforceInvariance */
                     : 0 /* AssignTypeFlags.Default */)) {
                     diag.addMessage(localize_1.LocAddendum.typedDictClosedExtraTypeMismatch().format({
@@ -4805,8 +4846,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                         if (isInvariant) {
                             diagAddendum = new diagnostic_1.DiagnosticAddendum();
                             diagAddendum.addMessage(localize_1.LocAddendum.overrideIsInvariant());
@@ -4981,7 +5022,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.newClsParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
             }
             if (classType) {
-                this._validateClsSelfParameterType(node, functionType, classType, /* isCls */ true);
+                this._validateClsSelfParamType(node, functionType, classType, /* isCls */ true);
             }
         }
         else if (((_b = node.d.name) === null || _b === void 0 ? void 0 : _b.d.value) === '_generate_next_value_') {
@@ -5010,7 +5051,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             if (classType) {
-                this._validateClsSelfParameterType(node, functionType, classType, /* isCls */ true);
+                this._validateClsSelfParamType(node, functionType, classType, /* isCls */ true);
             }
         }
         else {
@@ -5026,7 +5067,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (node.d.params[0].d.name) {
                         paramName = node.d.params[0].d.name.d.value;
                     }
-                    if (node.d.params[0].d.category !== 0 /* ParameterCategory.Simple */) {
+                    if (node.d.params[0].d.category !== 0 /* ParamCategory.Simple */) {
                         firstParamIsSimple = false;
                     }
                 }
@@ -5055,7 +5096,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             if (classType) {
-                this._validateClsSelfParameterType(node, functionType, classType, /* isCls */ false);
+                this._validateClsSelfParamType(node, functionType, classType, /* isCls */ false);
             }
         }
     }
@@ -5114,7 +5155,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     // Validates that the annotated type of a "self" or "cls" parameter is
     // compatible with the type of the class that contains it.
-    _validateClsSelfParameterType(node, functionType, classType, isCls) {
+    _validateClsSelfParamType(node, functionType, classType, isCls) {
         var _a;
         if (node.d.params.length < 1 || functionType.shared.parameters.length < 1) {
             return;
@@ -5122,6 +5163,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // If there is no type annotation, there's nothing to check because
         // the type will be inferred.d.typeAnnotation
         const paramInfo = functionType.shared.parameters[0];
+        const paramType = types_1.FunctionType.getParamType(functionType, 0);
         const paramAnnotation = (_a = node.d.params[0].d.annotation) !== null && _a !== void 0 ? _a : node.d.params[0].d.annotationComment;
         if (!paramAnnotation || !paramInfo.name) {
             return;
@@ -5130,8 +5172,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // use of class-scoped TypeVars, which are not allowed in this context
         // according to the typing spec.
         if (functionType.shared.name === '__init__' && functionType.shared.methodClass) {
-            const typeVars = (0, typeUtils_1.getTypeVarArgumentsRecursive)(paramInfo.type);
-            if (typeVars.some((typeVar) => { var _a; return typeVar.priv.scopeId === ((_a = functionType.shared.methodClass) === null || _a === void 0 ? void 0 : _a.shared.typeVarScopeId); })) {
+            const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(paramType);
+            if (typeVars.some((typeVar) => {
+                var _a;
+                return typeVar.priv.scopeId === ((_a = functionType.shared.methodClass) === null || _a === void 0 ? void 0 : _a.shared.typeVarScopeId) &&
+                    !types_1.TypeVarType.isSelf(typeVar);
+            })) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramAnnotation);
             }
         }
@@ -5140,20 +5186,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.ClassType.isProtocolClass(classType)) {
             return;
         }
-        const paramType = this._evaluator.makeTopLevelTypeVarsConcrete(paramInfo.type);
+        const concreteParamType = this._evaluator.makeTopLevelTypeVarsConcrete(paramType);
         const expectedType = isCls ? classType : (0, typeUtils_1.convertToInstance)(classType);
         // If the declared type is a protocol class or instance, skip
         // the check. This has legitimate uses for mix-in classes.
-        if ((0, types_1.isInstantiableClass)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
+        if ((0, types_1.isInstantiableClass)(concreteParamType) && types_1.ClassType.isProtocolClass(concreteParamType)) {
             return;
         }
-        if ((0, types_1.isClassInstance)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
+        if ((0, types_1.isClassInstance)(concreteParamType) && types_1.ClassType.isProtocolClass(concreteParamType)) {
             return;
         }
         // If the method starts with a `*args: P.args`, skip the check.
-        if (paramInfo.category === 1 /* ParameterCategory.ArgsList */ &&
-            (0, types_1.isParamSpec)(paramInfo.type) &&
-            paramInfo.type.priv.paramSpecAccess === 'args') {
+        if (paramInfo.category === 1 /* ParamCategory.ArgsList */ &&
+            (0, types_1.isParamSpec)(paramType) &&
+            paramType.priv.paramSpecAccess === 'args') {
             return;
         }
         // Don't enforce this for an overloaded method because the "self" param
@@ -5170,8 +5216,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             types_1.ClassType.isBuiltIn(classType, 'str')) {
             return;
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType));
-        if (!this._evaluator.assignType(paramType, expectedType, /* diag */ undefined, typeVarContext)) {
+        if (!this._evaluator.assignType(paramType, expectedType)) {
             // We exempt Never from this check because it has a legitimate use in this case.
             if (!(0, types_1.isNever)(paramType)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.clsSelfParamTypeMismatch().format({
@@ -5198,7 +5243,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
-        declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
+        declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
         let generatorType;
         if (!enclosingFunctionNode.d.isAsync &&
             (0, types_1.isClassInstance)(declaredReturnType) &&
@@ -5221,7 +5266,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const generatorTypeArgs = [yieldType, sendType !== null && sendType !== void 0 ? sendType : types_1.UnknownType.create(), types_1.UnknownType.create()];
-        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, generatorTypeArgs, /* isTypeArgumentExplicit */ true));
+        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(generatorType, generatorTypeArgs));
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
             const errorMessage = enclosingFunctionNode.d.isAsync
@@ -5295,7 +5340,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Were all of the exception types overridden?
                 if (typesOfThisExcept.length > 0 && typesOfThisExcept.length === overriddenExceptionCount) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedExcept, localize_1.LocMessage.unreachableExcept() + diagAddendum.getString(), except.d.typeExpr);
-                    this._evaluator.addUnreachableCode(except, except.d.exceptSuite);
+                    this._evaluator.addUnreachableCode(except, typeEvaluatorTypes_1.Reachability.UnreachableByAnalysis, except.d.exceptSuite);
                 }
             }
             (0, collectionUtils_1.appendArray)(exceptionTypesSoFar, typesOfThisExcept);