@zzzen/pyright-internal 1.2.0-dev.20240121 → 1.2.0-dev.20240218

package/dist/analyzer/checker.js

@@ -494,7 +494,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitFor(node) {
         this._evaluator.evaluateTypesForStatement(node);
         if (node.typeComment) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidTypeForm, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
         }
         return true;
     }
@@ -534,7 +534,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.evaluateTypesForStatement(item);
         });
         if (node.typeComment) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidTypeForm, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
         }
         return true;
     }
@@ -611,7 +611,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if (returnTypeResult.expectedTypeDiagAddendum) {
                             diagAddendum = returnTypeResult.expectedTypeDiagAddendum;
                         }
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnTypeMismatch().format({
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.returnTypeMismatch().format({
                             exprType: this._evaluator.printType(returnType),
                             returnType: this._evaluator.printType(declaredReturnType),
                         }) + diagAddendum.getString(), (_b = node.returnExpression) !== null && _b !== void 0 ? _b : node, (_c = returnTypeResult.expectedTypeDiagAddendum) === null || _c === void 0 ? void 0 : _c.getEffectiveTextRange());
@@ -767,11 +767,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const baseType = this._evaluator.getType(node.baseExpression);
         if (baseType) {
             (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
+                const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
                 if ((0, types_1.isClassInstance)(subtype) &&
-                    subtype.tupleTypeArguments &&
-                    !(0, typeUtils_1.isUnboundedTupleClass)(subtype) &&
-                    !this._evaluator.isTypeSubsumedByOtherType(subtype, baseType, /* allowAnyToSubsume */ false)) {
-                    const tupleLength = subtype.tupleTypeArguments.length;
+                    (tupleType === null || tupleType === void 0 ? void 0 : tupleType.tupleTypeArguments) &&
+                    !(0, typeUtils_1.isUnboundedTupleClass)(tupleType) &&
+                    !this._evaluator.isTypeSubsumedByOtherType(tupleType, baseType, /* allowAnyToSubsume */ false)) {
+                    const tupleLength = tupleType.tupleTypeArguments.length;
                     if (node.items.length === 1 &&
                         !node.trailingComma &&
                         node.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
@@ -1513,7 +1514,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const errorMessage = node.isAsync
                 ? localize_1.LocMessage.generatorAsyncReturnType()
                 : localize_1.LocMessage.generatorSyncReturnType();
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, errorMessage.format({ yieldType: this._evaluator.printType(types_1.AnyType.create()) }) +
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, errorMessage.format({ yieldType: this._evaluator.printType(types_1.AnyType.create()) }) +
                 diagAddendum.getString(), (_a = node.returnTypeAnnotation) !== null && _a !== void 0 ? _a : node.name);
         }
     }
@@ -1729,12 +1730,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         if (staticMethodCount > 0 && staticMethodCount < functionType.overloads.length) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overloadStaticMethodInconsistent().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadStaticMethodInconsistent().format({
                 name: node.name.value,
             }), (_c = (_b = (_a = functionType.overloads[0]) === null || _a === void 0 ? void 0 : _a.details.declaration) === null || _b === void 0 ? void 0 : _b.node.name) !== null && _c !== void 0 ? _c : node.name);
         }
         if (classMethodCount > 0 && classMethodCount < functionType.overloads.length) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overloadClassMethodInconsistent().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadClassMethodInconsistent().format({
                 name: node.name.value,
             }), (_f = (_e = (_d = functionType.overloads[0]) === null || _d === void 0 ? void 0 : _d.details.declaration) === null || _e === void 0 ? void 0 : _e.node.name) !== null && _f !== void 0 ? _f : node.name);
         }
@@ -2047,20 +2048,27 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         : [];
                 if (overloadedFunctions.length === 1) {
                     // There should never be a single overload.
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.singleOverload().format({ name }), primaryDecl.node.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.singleOverload().format({ name }), primaryDecl.node.name);
                 }
                 // If the file is not a stub and this is the first overload,
                 // verify that there is an implementation.
                 if (!this._fileInfo.isStubFile && overloadedFunctions.length > 0) {
                     let implementationFunction;
-                    if ((0, types_1.isOverloadedFunction)(type) && types_1.OverloadedFunctionType.getImplementation(type)) {
+                    let exemptMissingImplementation = false;
+                    if ((0, types_1.isOverloadedFunction)(type)) {
                         implementationFunction = types_1.OverloadedFunctionType.getImplementation(type);
+                        // If the implementation has no name, it was synthesized probably by a
+                        // decorator that used a callable with a ParamSpec that captured the
+                        // overloaded signature. We'll exempt it from this check.
+                        const overloads = types_1.OverloadedFunctionType.getOverloads(type);
+                        if (overloads.length > 0 && overloads[0].details.name === '') {
+                            exemptMissingImplementation = true;
+                        }
                     }
                     else if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isOverloaded(type)) {
                         implementationFunction = type;
                     }
                     if (!implementationFunction) {
-                        let exemptMissingImplementation = false;
                         const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(primaryDecl.node);
                         if (containingClassNode && containingClassNode.nodeType === 10 /* ParseNodeType.Class */) {
                             const classType = this._evaluator.getTypeOfClass(containingClassNode);
@@ -2079,7 +2087,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // If this is a method within a protocol class, don't require that
                         // there is an implementation.
                         if (!exemptMissingImplementation) {
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overloadWithoutImplementation().format({
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportNoOverloadImplementation, localize_1.LocMessage.overloadWithoutImplementation().format({
                                 name: primaryDecl.node.name.value,
                             }), primaryDecl.node.name);
                         }
@@ -2091,7 +2099,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const diag = new diagnostic_1.DiagnosticAddendum();
                             if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
                                 if (implementationFunction.details.declaration) {
-                                    const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overloadImplementationMismatch().format({
+                                    const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadImplementationMismatch().format({
                                         name,
                                         index: index + 1,
                                     }) + diag.getString(), implementationFunction.details.declaration.node.name);
@@ -2171,7 +2179,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (typeAliasDecl && decls.length > 1) {
             decls.forEach((decl) => {
                 if (decl !== typeAliasDecl) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasRedeclared().format({ name }), decl.node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, localize_1.LocMessage.typeAliasRedeclared().format({ name }), decl.node);
                 }
             });
         }
@@ -2279,7 +2287,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     duplicateIsOk = true;
                 }
                 if (!duplicateIsOk) {
-                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.obscuredClassDeclaration().format({ name }), otherDecl.node.name);
+                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, localize_1.LocMessage.obscuredClassDeclaration().format({ name }), otherDecl.node.name);
                     addPrimaryDeclInfo(diag);
                 }
             }
@@ -2312,7 +2320,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     duplicateIsOk = true;
                 }
                 if (!duplicateIsOk) {
-                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, otherDecl.isMethod
+                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, otherDecl.isMethod
                         ? localize_1.LocMessage.obscuredMethodDeclaration().format({ name })
                         : localize_1.LocMessage.obscuredFunctionDeclaration().format({ name }), otherDecl.node.name);
                     addPrimaryDeclInfo(diag);
@@ -2328,7 +2336,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     if (!duplicateIsOk) {
                         const message = localize_1.LocMessage.obscuredParameterDeclaration();
-                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name }), otherDecl.node.name);
+                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, message.format({ name }), otherDecl.node.name);
                         addPrimaryDeclInfo(diag);
                     }
                 }
@@ -2349,14 +2357,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             duplicateIsOk = true;
                         }
                         if (!duplicateIsOk) {
-                            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.obscuredVariableDeclaration().format({ name }), otherDecl.node);
+                            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, localize_1.LocMessage.obscuredVariableDeclaration().format({ name }), otherDecl.node);
                             addPrimaryDeclInfo(diag);
                         }
                     }
                 }
             }
             else if (otherDecl.type === 4 /* DeclarationType.TypeAlias */) {
-                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.obscuredTypeAliasDeclaration().format({ name }), otherDecl.node.name);
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, localize_1.LocMessage.obscuredTypeAliasDeclaration().format({ name }), otherDecl.node.name);
                 addPrimaryDeclInfo(diag);
             }
         }
@@ -2547,7 +2555,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         if (!isValidType) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, isInstanceCheck
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, isInstanceCheck
                 ? localize_1.LocMessage.isInstanceInvalidType().format({
                     type: this._evaluator.printType(arg1Type),
                 }) + diag.getString()
@@ -2782,7 +2790,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 case 0 /* TypeCategory.Unbound */:
                     break;
                 case 6 /* TypeCategory.Class */:
-                    if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+                    if (types_1.ClassType.isBuiltIn(subtype, 'TypedDict')) {
+                        diag.addMessage(localize_1.LocAddendum.typedDictNotAllowed());
+                        isSupported = false;
+                    }
+                    else if (types_1.ClassType.isBuiltIn(subtype, 'NamedTuple')) {
+                        diag.addMessage(localize_1.LocAddendum.namedTupleNotAllowed());
+                        isSupported = false;
+                    }
+                    else if ((0, typeUtils_1.isNoneInstance)(subtype)) {
                         diag.addMessage(localize_1.LocAddendum.noneNotAllowed());
                         isSupported = false;
                     }
@@ -2809,6 +2825,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.LocAddendum.newTypeClassNotAllowed());
                         isSupported = false;
                     }
+                    else if (subtype.specialForm &&
+                        (0, types_1.isInstantiableClass)(subtype.specialForm) &&
+                        types_1.ClassType.isBuiltIn(subtype.specialForm, 'Annotated')) {
+                        diag.addMessage(localize_1.LocAddendum.annotatedNotAllowed());
+                        isSupported = false;
+                    }
                     break;
                 case 4 /* TypeCategory.Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
@@ -3027,10 +3049,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const type = this._evaluator.getType(node);
             if (type) {
                 if ((0, types_1.isUnbound)(type)) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.LocMessage.symbolIsUnbound().format({ name: node.value }), node);
+                    if (this._evaluator.isNodeReachable(node)) {
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.LocMessage.symbolIsUnbound().format({ name: node.value }), node);
+                    }
                 }
                 else if ((0, types_1.isPossiblyUnbound)(type)) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.LocMessage.symbolIsPossiblyUnbound().format({ name: node.value }), node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPossiblyUnboundVariable, localize_1.LocMessage.symbolIsPossiblyUnbound().format({ name: node.value }), node);
                 }
             }
         }
@@ -3324,7 +3348,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (!ParseTreeUtils.isSuiteEmpty(node.suite) &&
                         !types_1.FunctionType.isOverloaded(functionType) &&
                         !types_1.FunctionType.isAsync(functionType)) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnReturnsNone(), returnAnnotation);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.noReturnReturnsNone(), returnAnnotation);
                     }
                 }
                 else if (!types_1.FunctionType.isAbstractMethod(functionType)) {
@@ -3337,7 +3361,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // an abstract method or a protocol method and don't require that
                         // the return type matches. This check can also be skipped for an overload.
                         if (!ParseTreeUtils.isSuiteEmpty(node.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnMissing().format({
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.returnMissing().format({
                                 returnType: this._evaluator.printType(declaredReturnType),
                             }) + diagAddendum.getString(), returnAnnotation);
                         }
@@ -3379,15 +3403,27 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateFinalMemberOverrides(classType) {
         classType.details.fields.forEach((localSymbol, name) => {
             const parentSymbol = (0, typeUtils_1.lookUpClassMember)(classType, name, 1 /* MemberAccessFlags.SkipOriginalClass */);
-            if (parentSymbol &&
-                (0, types_1.isInstantiableClass)(parentSymbol.classType) &&
-                this._evaluator.isFinalVariable(parentSymbol.symbol) &&
-                !SymbolNameUtils.isPrivateName(name)) {
-                const decl = localSymbol.getDeclarations()[0];
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalRedeclarationBySubclass().format({
-                    name,
-                    className: parentSymbol.classType.details.name,
-                }), decl.node);
+            if (parentSymbol && (0, types_1.isInstantiableClass)(parentSymbol.classType) && !SymbolNameUtils.isPrivateName(name)) {
+                // Did the parent class explicitly declare the variable as final?
+                if (this._evaluator.isFinalVariable(parentSymbol.symbol)) {
+                    const decl = localSymbol.getDeclarations()[0];
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalRedeclarationBySubclass().format({
+                        name,
+                        className: parentSymbol.classType.details.name,
+                    }), decl.node);
+                }
+                else if (types_1.ClassType.isReadOnlyInstanceVariables(parentSymbol.classType) &&
+                    !SymbolNameUtils.isDunderName(name)) {
+                    // If the parent class is a named tuple, all instance variables
+                    // (other than dundered ones) are implicitly final.
+                    const decl = localSymbol.getDeclarations()[0];
+                    if (decl.type === 1 /* DeclarationType.Variable */) {
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.namedTupleEntryRedeclared().format({
+                            name,
+                            className: parentSymbol.classType.details.name,
+                        }), decl.node);
+                    }
+                }
             }
         });
     }
@@ -3401,8 +3437,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const declaredValueType = (0, enums_1.getEnumDeclaredValueType)(this._evaluator, classType, /* declaredTypesOnly */ true);
         // Is there a custom "__new__" and/or "__init__" method? If so, we'll
         // verify that the signature of these calls is compatible with the values.
-        const newMemberTypeResult = (0, constructors_1.getBoundNewMethod)(this._evaluator, node.name, classType, 2 /* MemberAccessFlags.SkipBaseClasses */);
-        const initMemberTypeResult = (0, constructors_1.getBoundInitMethod)(this._evaluator, node.name, types_1.ClassType.cloneAsInstance(classType), 2 /* MemberAccessFlags.SkipBaseClasses */);
+        let newMemberTypeResult = (0, constructors_1.getBoundNewMethod)(this._evaluator, node.name, classType, 4 /* MemberAccessFlags.SkipObjectBaseClass */);
+        // If this __new__ comes from a built-in class like Enum, we'll ignore it.
+        if (newMemberTypeResult === null || newMemberTypeResult === void 0 ? void 0 : newMemberTypeResult.classType) {
+            if ((0, types_1.isClass)(newMemberTypeResult.classType) && types_1.ClassType.isBuiltIn(newMemberTypeResult.classType)) {
+                newMemberTypeResult = undefined;
+            }
+        }
+        let initMemberTypeResult = (0, constructors_1.getBoundInitMethod)(this._evaluator, node.name, types_1.ClassType.cloneAsInstance(classType), 4 /* MemberAccessFlags.SkipObjectBaseClass */);
+        // If this __init__ comes from a built-in class like Enum, we'll ignore it.
+        if (initMemberTypeResult === null || initMemberTypeResult === void 0 ? void 0 : initMemberTypeResult.classType) {
+            if ((0, types_1.isClass)(initMemberTypeResult.classType) && types_1.ClassType.isBuiltIn(initMemberTypeResult.classType)) {
+                initMemberTypeResult = undefined;
+            }
+        }
         classType.details.fields.forEach((symbol, name) => {
             var _a;
             // Enum members don't have type annotations.
@@ -3456,7 +3504,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!(0, types_1.isClassInstance)(assignedValueType) ||
                     !types_1.ClassType.isSameGenericClass(assignedValueType, classType)) {
                     if (!this._evaluator.assignType(declaredValueType, assignedValueType, diag)) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAssignmentMismatch().format(this._evaluator.printSrcDestTypes(assignedValueType, declaredValueType)) + diag.getString(), errorNode);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(this._evaluator.printSrcDestTypes(assignedValueType, declaredValueType)) + diag.getString(), errorNode);
                     }
                 }
             }
@@ -4061,67 +4109,60 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // This check can be expensive, so don't perform it if the corresponding
             // rule is disabled.
             if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== 'none') {
-                if (!(0, types_1.isAnyOrUnknown)(overriddenType) && !(0, types_1.isAnyOrUnknown)(overrideType)) {
-                    // If the child class overrides this symbol with its own type, make sure
-                    // the override is compatible with the overridden symbol. Otherwise use the
-                    // override type.
-                    // Verify that the override type is assignable to (same or narrower than)
-                    // the declared type of the base symbol.
-                    const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overriddenClassAndSymbol.symbol);
-                    let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
-                    // If the entry is a member of a frozen dataclass, it is immutable,
-                    // so it does not need to be invariant.
-                    if (types_1.ClassType.isFrozenDataClass(overriddenClassAndSymbol.classType) &&
-                        overriddenClassAndSymbol.classType.details.dataClassEntries) {
-                        const dataclassEntry = overriddenClassAndSymbol.classType.details.dataClassEntries.find((entry) => entry.name === memberName);
-                        if (dataclassEntry) {
-                            isInvariant = false;
-                        }
+                const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overriddenClassAndSymbol.symbol);
+                let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
+                // If the entry is a member of a frozen dataclass, it is immutable,
+                // so it does not need to be invariant.
+                if (types_1.ClassType.isFrozenDataClass(overriddenClassAndSymbol.classType) &&
+                    overriddenClassAndSymbol.classType.details.dataClassEntries) {
+                    const dataclassEntry = overriddenClassAndSymbol.classType.details.dataClassEntries.find((entry) => entry.name === memberName);
+                    if (dataclassEntry) {
+                        isInvariant = false;
                     }
-                    let overriddenTDEntry;
-                    if (overriddenClassAndSymbol.classType.details.typedDictEntries) {
-                        overriddenTDEntry = overriddenClassAndSymbol.classType.details.typedDictEntries.get(memberName);
-                        if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
-                            isInvariant = false;
-                        }
+                }
+                let overriddenTDEntry;
+                if (overriddenClassAndSymbol.classType.details.typedDictEntries) {
+                    overriddenTDEntry = overriddenClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                    if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                        isInvariant = false;
                     }
-                    let overrideTDEntry;
-                    if (overrideClassAndSymbol.classType.details.typedDictEntries) {
-                        overrideTDEntry = overrideClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                }
+                let overrideTDEntry;
+                if (overrideClassAndSymbol.classType.details.typedDictEntries) {
+                    overrideTDEntry = overrideClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                }
+                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 */)) {
+                    diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
+                        classType: childClassType.details.name,
+                        name: memberName,
+                    }), errorNode);
+                }
+                else if (overriddenTDEntry && overrideTDEntry) {
+                    let isRequiredCompatible;
+                    let isReadOnlyCompatible = true;
+                    // If both classes are TypedDicts and they both define this field,
+                    // make sure the attributes are compatible.
+                    if (overriddenTDEntry.isReadOnly) {
+                        isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
                     }
-                    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 */)) {
-                        diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
-                            classType: childClassType.details.name,
+                    else {
+                        isReadOnlyCompatible = !overrideTDEntry.isReadOnly;
+                        isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+                    }
+                    if (!isRequiredCompatible) {
+                        const message = overrideTDEntry.isRequired
+                            ? localize_1.LocMessage.typedDictFieldRequiredRedefinition
+                            : localize_1.LocMessage.typedDictFieldNotRequiredRedefinition;
+                        diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, message().format({ name: memberName }), errorNode);
+                    }
+                    else if (!isReadOnlyCompatible) {
+                        diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
                             name: memberName,
                         }), errorNode);
                     }
-                    else if (overriddenTDEntry && overrideTDEntry) {
-                        let isRequiredCompatible;
-                        let isReadOnlyCompatible = true;
-                        // If both classes are TypedDicts and they both define this field,
-                        // make sure the attributes are compatible.
-                        if (overriddenTDEntry.isReadOnly) {
-                            isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
-                        }
-                        else {
-                            isReadOnlyCompatible = !overrideTDEntry.isReadOnly;
-                            isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
-                        }
-                        if (!isRequiredCompatible) {
-                            const message = overrideTDEntry.isRequired
-                                ? localize_1.LocMessage.typedDictFieldRequiredRedefinition
-                                : localize_1.LocMessage.typedDictFieldNotRequiredRedefinition;
-                            diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, message().format({ name: memberName }), errorNode);
-                        }
-                        else if (!isReadOnlyCompatible) {
-                            diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
-                                name: memberName,
-                            }), errorNode);
-                        }
-                    }
                 }
             }
         }
@@ -4160,7 +4201,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     overloads.forEach((overload) => {
                         var _a, _b;
                         if (types_1.FunctionType.isFinal(overload) && ((_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overloadFinalInconsistencyImpl().format({
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyImpl().format({
                                 name: overload.details.name,
                             }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.details.declaration)) !== null && _b !== void 0 ? _b : overload.details.declaration.node);
                         }
@@ -4172,7 +4213,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 overloads.slice(1).forEach((overload, index) => {
                     var _a, _b;
                     if (types_1.FunctionType.isFinal(overload) && ((_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overloadFinalInconsistencyNoImpl().format({
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyNoImpl().format({
                             name: overload.details.name,
                             index: index + 2,
                         }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.details.declaration)) !== null && _b !== void 0 ? _b : overload.details.declaration.node);
@@ -4851,7 +4892,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const errorMessage = enclosingFunctionNode.isAsync
                 ? localize_1.LocMessage.generatorAsyncReturnType()
                 : localize_1.LocMessage.generatorSyncReturnType();
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, errorMessage.format({ yieldType: this._evaluator.printType(yieldType) }) +
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, errorMessage.format({ yieldType: this._evaluator.printType(yieldType) }) +
                 ((_a = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getString()) !== null && _a !== void 0 ? _a : diagAddendum.getString()), (_b = node.expression) !== null && _b !== void 0 ? _b : node, (_d = (_c = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.expression) !== null && _d !== void 0 ? _d : node);
         }
     }
@@ -4918,7 +4959,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.reportGeneralTypeIssues, localize_1.LocMessage.unreachableExcept() + diagAddendum.getString(), except.typeExpression);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedExcept, localize_1.LocMessage.unreachableExcept() + diagAddendum.getString(), except.typeExpression);
                     this._evaluator.addUnreachableCode(except, except.exceptSuite);
                 }
             }