@zzzen/pyright-internal 1.2.0-dev.20240714 → 1.2.0-dev.20240728

package/dist/analyzer/checker.js

@@ -70,6 +70,7 @@ const staticExpressions_1 = require("./staticExpressions");
 const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
 const symbolUtils_1 = require("./symbolUtils");
 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");
@@ -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,31 +219,31 @@ 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 '_'.
@@ -286,7 +287,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.getEffectiveParamType(functionTypeResult.functionType, kwargsIndex);
                 if ((0, types_1.isClass)(kwargsType) && kwargsType.shared.typedDictEntries) {
                     const overlappingEntries = new Set();
                     kwargsType.shared.typedDictEntries.knownItems.forEach((_, name) => {
@@ -304,7 +305,7 @@ 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) {
+                    if (param.category !== 0 /* ParamCategory.Simple */ && param.name && param.type.priv.paramSpecAccess) {
                         return true;
                     }
                 }
@@ -547,7 +548,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let returnTypeResult;
         let returnType;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-        const declaredReturnType = enclosingFunctionNode
+        let declaredReturnType = enclosingFunctionNode
             ? this._evaluator.getFunctionDeclaredReturnType(enclosingFunctionNode)
             : undefined;
         if (node.d.expr) {
@@ -577,33 +578,34 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnContainsReturn(), node);
                 }
                 else {
+                    const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                    declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
+                    declaredReturnType = this._evaluator.stripTypeGuard(declaredReturnType);
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
                     if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
+                    /* destTypeVarContext */ new typeVarContext_1.TypeVarContext())) {
                         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);
+                        const uniqueTypeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(declaredReturnType);
                         if (uniqueTypeVars && uniqueTypeVars.some((typeVar) => typeVar.shared.constraints.length > 0)) {
                             const typeVarContext = new typeVarContext_1.TypeVarContext();
                             for (const typeVar of uniqueTypeVars) {
                                 if (typeVar.shared.constraints.length > 0) {
                                     const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, typeVar);
                                     if (narrowedType) {
-                                        typeVarContext.setTypeVarType(typeVar, narrowedType);
+                                        (0, typeUtils_1.setTypeVarType)(typeVarContext, typeVar, narrowedType);
                                         typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(typeVar));
                                     }
                                 }
                             }
                             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 */)) {
+                                let adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
+                                adjustedReturnType = this._evaluator.stripTypeGuard(adjustedReturnType);
+                                if (this._evaluator.assignType(adjustedReturnType, returnType, diagAddendum)) {
                                     returnTypeMatches = true;
                                 }
                             }
@@ -721,8 +723,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);
                     }
@@ -772,15 +774,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;
                 }
@@ -961,7 +961,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');
@@ -1053,7 +1053,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitTypeParameterList(node) {
-        this._typeParameterLists.push(node);
+        this._typeParamLists.push(node);
         return true;
     }
     visitTypeParameter(node) {
@@ -1069,14 +1069,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;
                 }
@@ -1465,12 +1465,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;
@@ -1487,12 +1483,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;
@@ -1549,8 +1541,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
@@ -1607,7 +1598,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;
                         }
                     }
@@ -1702,7 +1693,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) {
@@ -1851,12 +1842,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.FunctionType.isInstanceMethod(functionType) && functionType.shared.name === '__get__') {
             return false;
         }
-        let flags = 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlapCheck */;
+        let flags = 64 /* AssignTypeFlags.SkipReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlap */;
         if (partialOverlap) {
-            flags |= 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */;
+            flags |= 32 /* AssignTypeFlags.PartialOverloadOverlap */;
         }
         return this._evaluator.assignType(functionType, prevOverload, 
-        /* diag */ undefined, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType)), 
+        /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
         /* srcTypeVarContext */ undefined, flags);
     }
     _isLegalOverloadImplementation(overload, implementation, diag) {
@@ -1864,7 +1855,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
         const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ |
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
             2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
             512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
@@ -1889,13 +1880,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;
                 }
             }
@@ -2014,8 +2006,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);
                     });
@@ -2064,6 +2056,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);
                 });
@@ -2071,7 +2064,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);
@@ -2176,6 +2169,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;
@@ -2323,7 +2328,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 */) {
@@ -2346,8 +2351,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;
                     }
@@ -2360,7 +2365,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;
@@ -2393,7 +2398,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;
@@ -2405,10 +2410,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;
@@ -2430,7 +2435,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;
@@ -2521,7 +2526,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;
                 }
@@ -2577,8 +2582,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;
@@ -2622,10 +2627,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;
                 }
             }
@@ -2651,8 +2654,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);
                     });
                 }
@@ -2707,8 +2710,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) {
@@ -2888,7 +2891,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());
@@ -2988,7 +2991,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (errorMessage) {
-            this._reportDeprecatedDiagnostic(node, errorMessage, info.deprecationMessage);
+            this._reportDeprecatedDiagnostic(node, errorMessage, info.deprecatedMessage);
         }
     }
     _reportDeprecatedUseForType(node, type, isImportFromTyping = false) {
@@ -3104,18 +3107,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,
+                            }));
                         }
                     }
                 }
@@ -3374,9 +3369,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');
@@ -3397,13 +3390,13 @@ 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 typeGuardType = returnType.priv.typeArgs[0];
             // 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 = types_1.FunctionType.getEffectiveParamType(functionType, paramIndex);
             // 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);
@@ -3607,6 +3600,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 */);
@@ -3618,25 +3615,23 @@ 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, 
+                        this._evaluator.validateCallArgs(errorNode, argList, newMemberTypeResult, 
                         /* typeVarContext */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
+                        /* inferenceContext */ undefined);
                     }
                     if (initMemberTypeResult) {
-                        this._evaluator.validateCallArguments(errorNode, argList, initMemberTypeResult, 
+                        this._evaluator.validateCallArgs(errorNode, argList, initMemberTypeResult, 
                         /* typeVarContext */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
+                        /* inferenceContext */ undefined);
                     }
                 }
             }
@@ -3684,7 +3679,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 ||
@@ -3712,7 +3707,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.getEffectiveParamType(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 +3880,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 +3889,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) => {
+        classType.shared.typeParams.forEach((param, paramIndex) => {
             // Skip variadics and ParamSpecs.
-            if (param.shared.isVariadic || param.shared.isParamSpec) {
+            if ((0, types_1.isTypeVarTuple)(param) || (0, types_1.isParamSpec)(param)) {
                 return;
             }
             // Skip type variables with auto-variance.
@@ -3905,20 +3900,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 +3927,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 +4030,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.SkipFunctionReturnTypeCheck */) ||
+        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
             /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */)) {
+            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
             const initDecl = initMemberType.shared.declaration;
             const newDecl = newMemberType.shared.declaration;
@@ -4101,7 +4090,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(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) {
+                if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.shared.typeParams.length > 0) {
                     const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, typeVarContext);
                     // 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));
@@ -4208,10 +4197,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         let overriddenType = this._evaluator.getEffectiveTypeOfSymbol(overriddenClassAndSymbol.symbol);
-        overriddenType = (0, typeUtils_1.partiallySpecializeType)(overriddenType, overriddenClassAndSymbol.classType);
+        overriddenType = (0, typeUtils_1.partiallySpecializeType)(overriddenType, overriddenClassAndSymbol.classType, this._evaluator.getTypeClassType());
         const overrideSymbol = overrideClassAndSymbol.symbol;
         let overrideType = this._evaluator.getEffectiveTypeOfSymbol(overrideSymbol);
-        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, overrideClassAndSymbol.classType);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, overrideClassAndSymbol.classType, this._evaluator.getTypeClassType());
         const childOverrideSymbol = types_1.ClassType.getSymbolTable(childClassType).get(memberName);
         const childOverrideType = childOverrideSymbol
             ? this._evaluator.getEffectiveTypeOfSymbol(childOverrideSymbol)
@@ -4352,7 +4341,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const subclassPropMethod = methodAccessor(overrideSymbolType);
             // Is the method present on the base class but missing in the subclass?
             if (baseClassPropMethod) {
-                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, overriddenClassType);
+                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, overriddenClassType, this._evaluator.getTypeClassType());
                 if ((0, types_1.isFunction)(baseClassMethodType)) {
                     if (!subclassPropMethod) {
                         // The method is missing.
@@ -4373,7 +4362,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     else {
-                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, overrideClassType);
+                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, overrideClassType, this._evaluator.getTypeClassType());
                         if ((0, types_1.isFunction)(subclassMethodType)) {
                             if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, overrideClassType, diagAddendum.createAddendum())) {
                                 diagAddendum.addMessage(localize_1.LocAddendum.propertyMethodIncompatible().format({
@@ -4665,8 +4654,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const baseClass = baseClassAndSymbol.classType;
         const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType));
-        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, childClassSelf);
-        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, childClassSelf);
+        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), childClassSelf);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, this._evaluator.getTypeClassType(), childClassSelf);
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             // Determine whether this is an attempt to override a method marked @final.
@@ -4912,7 +4901,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const subclassPropMethod = methodAccessor(childType);
             // Is the method present on the base class but missing in the subclass?
             if (baseClassPropMethod) {
-                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType);
+                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType, this._evaluator.getTypeClassType());
                 if ((0, types_1.isFunction)(baseClassMethodType)) {
                     if (!subclassPropMethod) {
                         // The method is missing.
@@ -4933,7 +4922,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     else {
-                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType);
+                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType, this._evaluator.getTypeClassType());
                         if ((0, types_1.isFunction)(subclassMethodType)) {
                             if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, childClassType, diagAddendum.createAddendum())) {
                                 diagAddendum.addMessage(localize_1.LocAddendum.propertyMethodIncompatible().format({
@@ -4981,7 +4970,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 +4999,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 +5015,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 +5044,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 +5103,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;
@@ -5130,8 +5119,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)(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) &&
+                    !typeVar.shared.isSynthesizedSelf;
+            })) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramAnnotation);
             }
         }
@@ -5151,7 +5144,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // If the method starts with a `*args: P.args`, skip the check.
-        if (paramInfo.category === 1 /* ParameterCategory.ArgsList */ &&
+        if (paramInfo.category === 1 /* ParamCategory.ArgsList */ &&
             (0, types_1.isParamSpec)(paramInfo.type) &&
             paramInfo.type.priv.paramSpecAccess === 'args') {
             return;
@@ -5193,10 +5186,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!functionTypeResult) {
             return;
         }
-        const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionTypeResult.functionType);
+        let declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionTypeResult.functionType);
         if (!declaredReturnType) {
             return;
         }
+        const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+        declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
         let generatorType;
         if (!enclosingFunctionNode.d.isAsync &&
             (0, types_1.isClassInstance)(declaredReturnType) &&
@@ -5219,7 +5214,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
@@ -5293,7 +5288,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);