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

package/dist/analyzer/checker.js

@@ -54,6 +54,7 @@ const constructors_1 = require("./constructors");
 const declaration_1 = require("./declaration");
 const declarationUtils_1 = require("./declarationUtils");
 const deprecatedSymbols_1 = require("./deprecatedSymbols");
+const enums_1 = require("./enums");
 const importResolver_1 = require("./importResolver");
 const importStatementUtils_1 = require("./importStatementUtils");
 const parameterUtils_1 = require("./parameterUtils");
@@ -102,7 +103,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             console.log(`Code complexity of module ${this._fileInfo.fileUri.toUserVisibleString()} is ${codeComplexity.toString()}`);
         }
         if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.codeTooComplexToAnalyze(), { start: 0, length: 0 });
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), { start: 0, length: 0 });
         }
         this._walkStatementsAndReportUnreachable(this._moduleNode.statements);
         // Mark symbols accessed by __all__ as accessed.
@@ -162,7 +163,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             !types_1.ClassType.isBuiltIn(baseClassType, 'Protocol') &&
                             !types_1.ClassType.isBuiltIn(baseClassType, 'Generic')) {
                             if (!types_1.ClassType.isProtocolClass(baseClassType)) {
-                                this._evaluator.addError(localize_1.Localizer.Diagnostic.protocolBaseClass().format({
+                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.protocolBaseClass().format({
                                     classType: classTypeResult.classType.details.name,
                                     baseType: baseClassType.details.name,
                                 }), arg.valueExpression);
@@ -188,8 +189,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateInstanceVariableInitialization(node, classTypeResult.classType);
             this._validateFinalClassNotAbstract(classTypeResult.classType, node);
             this._validateDataClassPostInit(classTypeResult.classType, node);
-            this._validateProtocolCompatibility(classTypeResult.classType, node);
-            this._reportDuplicateEnumMembers(classTypeResult.classType);
+            this._validateEnumMembers(classTypeResult.classType, node);
             if (types_1.ClassType.isTypedDictClass(classTypeResult.classType)) {
                 this._validateTypedDictClassSuite(node.suite);
             }
@@ -208,7 +208,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (!this._fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions && !this._fileInfo.isStubFile) {
             if (ParseTreeUtils.isUnannotatedFunction(node)) {
-                this._evaluator.addInformation(localize_1.Localizer.Diagnostic.unannotatedFunctionSkipped().format({ name: node.name.value }), node.name);
+                this._evaluator.addInformation(localize_1.LocMessage.unannotatedFunctionSkipped().format({ name: node.name.value }), node.name);
             }
         }
         const functionTypeResult = this._evaluator.getTypeOfFunction(node);
@@ -242,7 +242,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
                 if (param.name && param.category === 0 /* ParameterCategory.Simple */ && sawParamSpecArgs) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.namedParamAfterParamSpecArgs().format({ name: param.name.value }), param.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedParamAfterParamSpecArgs().format({ name: param.name.value }), param.name);
                 }
                 // Allow unknown and missing param types if the param is named '_'.
                 if (param.name && param.name.value !== '_') {
@@ -254,14 +254,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 ((0, types_1.isTypeVar)(paramType) &&
                                     paramType.details.isSynthesized &&
                                     !paramType.details.isSynthesizedSelf)) {
-                                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
+                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
                             }
                             else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
                                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.paramType().format({
+                                diagAddendum.addMessage(localize_1.LocAddendum.paramType().format({
                                     paramType: this._evaluator.printType(paramType, { expandTypeAlias: true }),
                                 }));
-                                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypePartiallyUnknown().format({
+                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.paramTypePartiallyUnknown().format({
                                     paramName: param.name.value,
                                 }) + diagAddendum.getString(), param.name);
                             }
@@ -277,7 +277,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             }
                         }
                         if (!hasAnnotation && this._fileInfo.diagnosticRuleSet.reportMissingParameterType !== 'none') {
-                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingParameterType, diagnosticRules_1.DiagnosticRule.reportMissingParameterType, localize_1.Localizer.Diagnostic.paramAnnotationMissing().format({ name: param.name.value }), param.name);
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingParameterType, localize_1.LocMessage.paramAnnotationMissing().format({ name: param.name.value }), param.name);
                         }
                     }
                 }
@@ -294,7 +294,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     });
                     if (overlappingEntries.size > 0) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overlappingKeywordArgs().format({
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overlappingKeywordArgs().format({
                             names: [...overlappingEntries.values()].join(', '),
                         }), (_a = node.parameters[kwargsIndex].typeAnnotation) !== null && _a !== void 0 ? _a : node.parameters[kwargsIndex]);
                     }
@@ -310,13 +310,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return false;
             });
             if (paramSpecParams.length === 1 && paramSpecParams[0].typeAnnotation) {
-                this._evaluator.addError(localize_1.Localizer.Diagnostic.paramSpecArgsKwargsUsage(), paramSpecParams[0].typeAnnotation);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecArgsKwargsUsage(), paramSpecParams[0].typeAnnotation);
             }
             // If this is a stub, ensure that the return type is specified.
             if (this._fileInfo.isStubFile) {
                 const returnAnnotation = node.returnTypeAnnotation || ((_b = node.functionAnnotationComment) === null || _b === void 0 ? void 0 : _b.returnTypeAnnotation);
                 if (!returnAnnotation) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypeUnknown(), node.name);
                 }
             }
             if (containingClassNode) {
@@ -344,7 +344,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         paramType.details.declaredVariance === 3 /* Variance.Covariant */ &&
                         !paramType.details.isSynthesized &&
                         !exemptMethods.some((name) => name === functionTypeResult.functionType.details.name)) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramTypeCovariant(), annotationNode);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramTypeCovariant(), annotationNode);
                     }
                 }
             }
@@ -356,7 +356,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this.walk(node.functionAnnotationComment);
             if (this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage !== 'none' &&
                 this._fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_5) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage, diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.Localizer.Diagnostic.typeCommentDeprecated(), node.functionAnnotationComment);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.LocMessage.typeCommentDeprecated(), node.functionAnnotationComment);
             }
         }
         this.walkMultiple(node.decorators);
@@ -371,7 +371,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             console.log(`Code complexity of function ${node.name.value} is ${codeComplexity.toString()}`);
         }
         if (isTooComplexToAnalyze) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.codeTooComplexToAnalyze(), node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), node.name);
         }
         else {
             this.walk(node.suite);
@@ -390,7 +390,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._reportDeprecatedClassProperty(node, functionTypeResult);
             // If this is not a method, @final is disallowed.
             if (!containingClassNode && types_1.FunctionType.isFinal(functionTypeResult.functionType)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.finalNonMethod().format({ name: node.name.value }), node.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalNonMethod().format({ name: node.name.value }), node.name);
             }
         }
         // If we're at the module level within a stub file, report a diagnostic
@@ -399,7 +399,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.isStubFile && node.name.value === '__getattr__') {
             const scope = (0, scopeUtils_1.getScopeForNode)(node);
             if ((scope === null || scope === void 0 ? void 0 : scope.type) === 3 /* ScopeType.Module */) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompleteStub, diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.Localizer.Diagnostic.stubUsesGetAttr(), node.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.LocMessage.stubUsesGetAttr(), node.name);
             }
         }
         this._scopedNodes.push(node);
@@ -432,10 +432,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const paramType = this._evaluator.getType(param.name);
                 if (paramType) {
                     if ((0, types_1.isUnknown)(paramType)) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
                     }
                     else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.paramTypePartiallyUnknown().format({ paramName: param.name.value }), param.name);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.paramTypePartiallyUnknown().format({ paramName: param.name.value }), param.name);
                     }
                 }
             }
@@ -443,10 +443,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const returnType = this._evaluator.getType(node.expression);
         if (returnType) {
             if ((0, types_1.isUnknown)(returnType)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.lambdaReturnTypeUnknown(), node.expression);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.lambdaReturnTypeUnknown(), node.expression);
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.lambdaReturnTypePartiallyUnknown().format({
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.lambdaReturnTypePartiallyUnknown().format({
                     returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
                 }), node.expression);
             }
@@ -465,11 +465,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const isRevealTypeCall = node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === 'reveal_type';
                 const returnType = this._evaluator.getType(node);
                 if (!isRevealTypeCall && returnType && this._isTypeValidForUnusedValueTest(returnType)) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCallResult, diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.Localizer.Diagnostic.unusedCallResult().format({
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.LocMessage.unusedCallResult().format({
                         type: this._evaluator.printType(returnType),
                     }), node);
                     if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, 'Coroutine')) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCoroutine, diagnosticRules_1.DiagnosticRule.reportUnusedCoroutine, localize_1.Localizer.Diagnostic.unusedCoroutine(), node);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCoroutine, localize_1.LocMessage.unusedCoroutine(), node);
                     }
                 }
             }
@@ -483,7 +483,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 node.expression.nodeType === 9 /* ParseNodeType.Call */) {
                 const returnType = this._evaluator.getType(node);
                 if (returnType && this._isTypeValidForUnusedValueTest(returnType)) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCallResult, diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.Localizer.Diagnostic.unusedCallResult().format({
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.LocMessage.unusedCallResult().format({
                         type: this._evaluator.printType(returnType),
                     }), node);
                 }
@@ -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.Localizer.Diagnostic.annotationNotSupported(), node.typeComment);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
         }
         return true;
     }
@@ -534,13 +534,14 @@ 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.Localizer.Diagnostic.annotationNotSupported(), node.typeComment);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
         }
         return true;
     }
     visitReturn(node) {
         var _a, _b, _c, _d, _e;
         let returnTypeResult;
+        let returnType;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         const declaredReturnType = enclosingFunctionNode
             ? this._evaluator.getFunctionDeclaredReturnType(enclosingFunctionNode)
@@ -552,24 +553,29 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // There is no return expression, so "None" is assumed.
             returnTypeResult = { type: this._evaluator.getNoneType() };
         }
+        returnType = returnTypeResult.type;
+        // If this type is a special form, use the special form instead.
+        if (returnType.specialForm) {
+            returnType = returnType.specialForm;
+        }
         // If the enclosing function is async and a generator, the return
         // statement is not allowed to have an argument. A syntax error occurs
         // at runtime in this case.
         if ((enclosingFunctionNode === null || enclosingFunctionNode === void 0 ? void 0 : enclosingFunctionNode.isAsync) && node.returnExpression) {
             const functionDecl = AnalyzerNodeInfo.getDeclaration(enclosingFunctionNode);
             if ((functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.type) === 5 /* DeclarationType.Function */ && functionDecl.isGenerator) {
-                this._evaluator.addError(localize_1.Localizer.Diagnostic.returnInAsyncGenerator(), node.returnExpression);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnInAsyncGenerator(), node.returnExpression);
             }
         }
         if (this._evaluator.isNodeReachable(node, /* sourceNode */ undefined) && enclosingFunctionNode) {
             if (declaredReturnType) {
                 if ((0, types_1.isNever)(declaredReturnType)) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnContainsReturn(), node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnContainsReturn(), node);
                 }
                 else {
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
-                    if (this._evaluator.assignType(declaredReturnType, returnTypeResult.type, diagAddendum, new typeVarContext_1.TypeVarContext(), 
+                    if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, new typeVarContext_1.TypeVarContext(), 
                     /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                         returnTypeMatches = true;
                     }
@@ -591,7 +597,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             }
                             if (!typeVarContext.isEmpty()) {
                                 const adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
-                                if (this._evaluator.assignType(adjustedReturnType, returnTypeResult.type, diagAddendum, 
+                                if (this._evaluator.assignType(adjustedReturnType, returnType, diagAddendum, 
                                 /* destTypeVarContext */ undefined, 
                                 /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                                     returnTypeMatches = true;
@@ -605,19 +611,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if (returnTypeResult.expectedTypeDiagAddendum) {
                             diagAddendum = returnTypeResult.expectedTypeDiagAddendum;
                         }
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeMismatch().format({
-                            exprType: this._evaluator.printType(returnTypeResult.type),
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, 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());
                     }
                 }
             }
-            if ((0, types_1.isUnknown)(returnTypeResult.type)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), (_d = node.returnExpression) !== null && _d !== void 0 ? _d : node);
+            if ((0, types_1.isUnknown)(returnType)) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.returnTypeUnknown(), (_d = node.returnExpression) !== null && _d !== void 0 ? _d : node);
             }
-            else if ((0, typeUtils_1.isPartlyUnknown)(returnTypeResult.type)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
-                    returnType: this._evaluator.printType(returnTypeResult.type, { expandTypeAlias: true }),
+            else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.returnTypePartiallyUnknown().format({
+                    returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
                 }), (_e = node.returnExpression) !== null && _e !== void 0 ? _e : node);
             }
         }
@@ -672,20 +678,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, typeUtils_1.isNoneInstance)(subtype)) {
                         if ((0, types_1.isClass)(subtype)) {
                             if (!(0, typeUtils_1.derivesFromClassRecursive)(subtype, baseExceptionType, /* ignoreUnknown */ false)) {
-                                diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                                diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
                                     type: this._evaluator.printType(subtype),
                                 }));
                             }
                         }
                         else {
-                            diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                            diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
                                 type: this._evaluator.printType(subtype),
                             }));
                         }
                     }
                 });
                 if (!diagAddendum.isEmpty()) {
-                    this._evaluator.addError(localize_1.Localizer.Diagnostic.expectedExceptionObj() + diagAddendum.getString(), node.valueExpression);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedExceptionObj() + diagAddendum.getString(), node.valueExpression);
                 }
             }
         }
@@ -714,7 +720,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if ((0, typeUtils_1.isTupleClass)(type) && type.tupleTypeArguments) {
                 if (type.tupleTypeArguments.length > 0) {
                     if (!(0, typeUtils_1.isUnboundedTupleClass)(type)) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportAssertAlwaysTrue, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.Localizer.Diagnostic.assertAlwaysTrue(), node.testExpression);
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportAssertAlwaysTrue, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.LocMessage.assertAlwaysTrue(), node.testExpression);
                     }
                 }
             }
@@ -727,7 +733,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.getType(node.typeAnnotationComment);
             if (this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage !== 'none' &&
                 this._fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_6) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage, diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.Localizer.Diagnostic.typeCommentDeprecated(), node.typeAnnotationComment);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.LocMessage.typeCommentDeprecated(), node.typeAnnotationComment);
             }
         }
         // If this isn't a class or global scope, explicit type aliases are not allowed.
@@ -739,7 +745,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (scope.type !== 2 /* ScopeType.Class */ &&
                         scope.type !== 3 /* ScopeType.Module */ &&
                         scope.type !== 4 /* ScopeType.Builtin */) {
-                        this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasNotInModuleOrClass(), node.leftExpression.typeAnnotation);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasNotInModuleOrClass(), node.leftExpression.typeAnnotation);
                     }
                 }
             }
@@ -778,7 +784,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             typeof subscriptType.literalValue === 'number') {
                             if ((subscriptType.literalValue >= 0 && subscriptType.literalValue >= tupleLength) ||
                                 (subscriptType.literalValue < 0 && subscriptType.literalValue + tupleLength < 0)) {
-                                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.tupleIndexOutOfRange().format({
+                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.tupleIndexOutOfRange().format({
                                     index: subscriptType.literalValue,
                                     type: this._evaluator.printType(subtype),
                                 }), node);
@@ -865,14 +871,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 unescapedResult.unescapeErrors.forEach((error) => {
                     if (error.errorType === 0 /* UnescapeErrorType.InvalidEscapeSequence */) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidStringEscapeSequence, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.Localizer.Diagnostic.stringUnsupportedEscape(), { start: start + error.offset, length: error.length });
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidStringEscapeSequence, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.LocMessage.stringUnsupportedEscape(), { start: start + error.offset, length: error.length });
                     }
                 });
                 // Prior to Python 3.12, it was not allowed to include a slash in an f-string.
                 if (fStringContainers.length > 0) {
                     const escapeOffset = token.escapedValue.indexOf('\\');
                     if (escapeOffset >= 0) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', localize_1.Localizer.Diagnostic.formatStringEscape(), { start, length: 1 });
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.formatStringEscape(), { start, length: 1 });
                     }
                 }
             });
@@ -881,7 +887,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (fStringContainers.length > 0) {
                 const quoteTypeMask = 1 /* StringTokenFlags.SingleQuote */ | 2 /* StringTokenFlags.DoubleQuote */ | 4 /* StringTokenFlags.Triplicate */;
                 if (fStringContainers.some((fStringContainer) => (fStringContainer.token.flags & quoteTypeMask) === (stringNode.token.flags & quoteTypeMask))) {
-                    this._evaluator.addError(localize_1.Localizer.Diagnostic.formatStringNestedQuote(), stringNode);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.formatStringNestedQuote(), stringNode);
                 }
             }
         }
@@ -889,7 +895,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.getType(node);
         }
         if (node.strings.length > 1 && !node.isParenthesized) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportImplicitStringConcatenation, diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation, localize_1.Localizer.Diagnostic.implicitStringConcat(), node);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportImplicitStringConcatenation, diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation, localize_1.LocMessage.implicitStringConcat(), node);
         }
         return true;
     }
@@ -964,7 +970,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             node.module.nameParts.length === 1 &&
             node.module.nameParts[0].value === '__future__') {
             if (!ParseTreeUtils.isValidLocationForFutureImport(node)) {
-                this._evaluator.addError(localize_1.Localizer.Diagnostic.futureImportLocationNotAllowed(), node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.futureImportLocationNotAllowed(), node);
             }
         }
         this._conditionallyReportShadowedImport(node);
@@ -980,7 +986,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 importInfo.isImportFound &&
                 importInfo.importType !== 2 /* ImportType.Local */ &&
                 !this._fileInfo.isStubFile) {
-                this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportWildcardImportFromLibrary, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.Localizer.Diagnostic.wildcardLibraryImport(), node.wildcardToken || node);
+                this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportWildcardImportFromLibrary, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.LocMessage.wildcardLibraryImport(), node.wildcardToken || node);
             }
         }
         return true;
@@ -1043,7 +1049,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const scope = (0, scopeUtils_1.getScopeForNode)(node);
         if (scope) {
             if (scope.type !== 2 /* ScopeType.Class */ && scope.type !== 3 /* ScopeType.Module */ && scope.type !== 4 /* ScopeType.Builtin */) {
-                this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasStatementBadScope(), node.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasStatementBadScope(), node.name);
             }
         }
         return true;
@@ -1102,7 +1108,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Type stub found, but source is missing.
-        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingModuleSource, diagnosticRules_1.DiagnosticRule.reportMissingModuleSource, localize_1.Localizer.Diagnostic.importSourceResolveFailure().format({
+        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingModuleSource, localize_1.LocMessage.importSourceResolveFailure().format({
             importName: importResult.importName,
             venv: this._fileInfo.executionEnvironment.name,
         }), node);
@@ -1133,14 +1139,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // All other types are problematic.
             isTypeBool = false;
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.conditionalRequiresBool().format({
+            diag.addMessage(localize_1.LocAddendum.conditionalRequiresBool().format({
                 operandType: this._evaluator.printType(expandedSubtype),
                 boolReturnType: this._evaluator.printType(boolReturnType),
             }));
             return undefined;
         });
         if (!isTypeBool) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.conditionalOperandInvalid().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.conditionalOperandInvalid().format({
                 type: this._evaluator.printType(operandType),
             }) + diag.getString(), node);
         }
@@ -1172,10 +1178,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         if (isExprFunction) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.Localizer.Diagnostic.functionInConditionalExpression(), expression);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.LocMessage.functionInConditionalExpression(), expression);
         }
         if (isCoroutine) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.Localizer.Diagnostic.coroutineInConditionalExpression(), expression);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.LocMessage.coroutineInConditionalExpression(), expression);
         }
     }
     _reportUnusedExpression(node) {
@@ -1214,7 +1220,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             reportAsUnused = false;
         }
         if (reportAsUnused) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedExpression, diagnosticRules_1.DiagnosticRule.reportUnusedExpression, localize_1.Localizer.Diagnostic.unusedExpression(), node);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedExpression, localize_1.LocMessage.unusedExpression(), node);
         }
     }
     _validateExhaustiveMatch(node) {
@@ -1227,11 +1233,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
         if (narrowedTypeResult && !(0, types_1.isNever)(narrowedTypeResult.type)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.matchIsNotExhaustiveType().format({
+            diagAddendum.addMessage(localize_1.LocAddendum.matchIsNotExhaustiveType().format({
                 type: this._evaluator.printType(narrowedTypeResult.type),
             }));
-            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.matchIsNotExhaustiveHint());
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMatchNotExhaustive, diagnosticRules_1.DiagnosticRule.reportMatchNotExhaustive, localize_1.Localizer.Diagnostic.matchIsNotExhaustive() + diagAddendum.getString(), node.subjectExpression);
+            diagAddendum.addMessage(localize_1.LocAddendum.matchIsNotExhaustiveHint());
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMatchNotExhaustive, localize_1.LocMessage.matchIsNotExhaustive() + diagAddendum.getString(), node.subjectExpression);
         }
     }
     _suppressUnboundCheck(callback) {
@@ -1247,7 +1253,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateIllegalDefaultParamInitializer(node) {
         if (this._fileInfo.diagnosticRuleSet.reportCallInDefaultInitializer !== 'none') {
             if (ParseTreeUtils.isWithinDefaultParamInitializer(node) && !this._fileInfo.isStubFile) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportCallInDefaultInitializer, diagnosticRules_1.DiagnosticRule.reportCallInDefaultInitializer, localize_1.Localizer.Diagnostic.defaultValueContainsCall(), node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallInDefaultInitializer, localize_1.LocMessage.defaultValueContainsCall(), node);
             }
         }
     }
@@ -1260,7 +1266,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             leftType.aliasName) {
             const nonInstantiable = ['List', 'Set', 'Dict', 'Tuple'];
             if (nonInstantiable.some((name) => name === leftType.aliasName)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.collectionAliasInstantiation().format({
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.collectionAliasInstantiation().format({
                     type: leftType.aliasName,
                     alias: leftType.details.name,
                 }), node.leftExpression);
@@ -1285,10 +1291,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isNever)(narrowedType)) {
             const getMessage = () => {
                 return node.operator === 41 /* OperatorType.In */
-                    ? localize_1.Localizer.Diagnostic.containmentAlwaysFalse()
-                    : localize_1.Localizer.Diagnostic.containmentAlwaysTrue();
+                    ? localize_1.LocMessage.containmentAlwaysFalse()
+                    : localize_1.LocMessage.containmentAlwaysTrue();
             };
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryContains, diagnosticRules_1.DiagnosticRule.reportUnnecessaryContains, getMessage().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryContains, getMessage().format({
                 leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
                 rightType: this._evaluator.printType(elementType, { expandTypeAlias: true }),
             }), node);
@@ -1314,11 +1320,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
         const getMessage = () => {
             return node.operator === 39 /* OperatorType.Is */
-                ? localize_1.Localizer.Diagnostic.comparisonAlwaysFalse()
-                : localize_1.Localizer.Diagnostic.comparisonAlwaysTrue();
+                ? localize_1.LocMessage.comparisonAlwaysFalse()
+                : localize_1.LocMessage.comparisonAlwaysTrue();
         };
         if (!foundMatchForNone) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
                 leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
                 rightType: this._evaluator.printType(rightType),
             }), node);
@@ -1345,8 +1351,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const getMessage = () => {
             return node.operator === 12 /* OperatorType.Equals */
-                ? localize_1.Localizer.Diagnostic.comparisonAlwaysFalse()
-                : localize_1.Localizer.Diagnostic.comparisonAlwaysTrue();
+                ? localize_1.LocMessage.comparisonAlwaysFalse()
+                : localize_1.LocMessage.comparisonAlwaysTrue();
         };
         // Check for the special case where the LHS and RHS are both literals.
         if ((0, typeUtils_1.isLiteralTypeOrUnion)(rightType) && (0, typeUtils_1.isLiteralTypeOrUnion)(leftType)) {
@@ -1358,7 +1364,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 });
                 if (!isPossiblyTrue) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
                         leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
                         rightType: this._evaluator.printType(rightType, { expandTypeAlias: true }),
                     }), node);
@@ -1385,7 +1391,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!isComparable) {
                 const leftTypeText = this._evaluator.printType(leftType, { expandTypeAlias: true });
                 const rightTypeText = this._evaluator.printType(rightType, { expandTypeAlias: true });
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
                     leftType: leftTypeText,
                     rightType: rightTypeText,
                 }), node);
@@ -1505,9 +1511,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
             const errorMessage = node.isAsync
-                ? localize_1.Localizer.Diagnostic.generatorAsyncReturnType()
-                : localize_1.Localizer.Diagnostic.generatorSyncReturnType();
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, errorMessage.format({ yieldType: this._evaluator.printType(types_1.AnyType.create()) }) +
+                ? 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()) }) +
                 diagAddendum.getString(), (_a = node.returnTypeAnnotation) !== null && _a !== void 0 ? _a : node.name);
         }
     }
@@ -1655,10 +1661,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     altTypeText = '"object"';
                 }
                 const diag = new diagnostic_1.DiagnosticAddendum();
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarUnnecessarySuggestion().format({
+                diag.addMessage(localize_1.LocAddendum.typeVarUnnecessarySuggestion().format({
                     type: altTypeText,
                 }));
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.Localizer.Diagnostic.typeVarUsedOnlyOnce().format({
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.typeVarUsedOnlyOnce().format({
                     name: usage.nodes[0].value,
                 }) + diag.getString(), usage.nodes[0]);
             }
@@ -1686,8 +1692,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 usage.paramTypeUsageCount === usage.paramTypeWithEllipsisUsageCount &&
                 !skipUnsolvableTypeVarCheck) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarUnsolvableRemedy());
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.Localizer.Diagnostic.typeVarPossiblyUnsolvable().format({
+                diag.addMessage(localize_1.LocAddendum.typeVarUnsolvableRemedy());
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.typeVarPossiblyUnsolvable().format({
                     name: usage.nodes[0].value,
                     param: (_a = usage.paramWithEllipsis) !== null && _a !== void 0 ? _a : '',
                 }) + diag.getString(), usage.nodes[0]);
@@ -1701,8 +1707,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 usage.paramTypeUsageCount === usage.paramTypeWithEllipsisUsageCount &&
                 !usage.isExempt) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarUnsolvableRemedy());
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.Localizer.Diagnostic.typeVarPossiblyUnsolvable().format({
+                diag.addMessage(localize_1.LocAddendum.typeVarUnsolvableRemedy());
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.typeVarPossiblyUnsolvable().format({
                     name: usage.nodes[0].value,
                     param: (_a = usage.paramWithEllipsis) !== null && _a !== void 0 ? _a : '',
                 }) + diag.getString(), usage.nodes[0]);
@@ -1723,12 +1729,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         if (staticMethodCount > 0 && staticMethodCount < functionType.overloads.length) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadStaticMethodInconsistent().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, 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(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadClassMethodInconsistent().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, 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);
         }
@@ -1738,7 +1744,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
             if (this._isOverlappingOverload(functionType, prevOverload, /* partialOverlap */ false)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overlappingOverload().format({
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overlappingOverload().format({
                     name: node.name.value,
                     obscured: prevOverloads.length + 1,
                     obscuredBy: i + 1,
@@ -1757,7 +1763,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
                     /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
                     const altNode = this._findNodeForOverload(node, prevOverload);
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overloadReturnTypeMismatch().format({
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overloadReturnTypeMismatch().format({
                         name: node.name.value,
                         newIndex: prevOverloads.length + 1,
                         prevIndex: i + 1,
@@ -1816,7 +1822,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const returnDiag = new diagnostic_1.DiagnosticAddendum();
         if (!(0, types_1.isNever)(overloadReturnType) &&
             !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
-            returnDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionReturnTypeMismatch().format({
+            returnDiag.addMessage(localize_1.LocAddendum.functionReturnTypeMismatch().format({
                 sourceType: this._evaluator.printType(overloadReturnType),
                 destType: this._evaluator.printType(implementationReturnType),
             }));
@@ -1863,7 +1869,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             case 53 /* ParseNodeType.Try */:
             case 58 /* ParseNodeType.With */: {
                 // These are not allowed.
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidStubStatement, diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.Localizer.Diagnostic.invalidStubStatement(), statement);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.LocMessage.invalidStubStatement(), statement);
                 break;
             }
             case 47 /* ParseNodeType.StatementList */: {
@@ -1922,7 +1928,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     if (!isValid) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidStubStatement, diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.Localizer.Diagnostic.invalidStubStatement(), substatement);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.LocMessage.invalidStubStatement(), substatement);
                     }
                 }
             }
@@ -1945,7 +1951,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         else {
             if ((0, types_1.isInstantiableClass)(exceptionType)) {
                 if (!derivesFromBaseException(exceptionType)) {
-                    diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                    diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
                         type: this._evaluator.printType(exceptionType),
                     }));
                 }
@@ -1960,13 +1966,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     if ((0, types_1.isInstantiableClass)(subtype)) {
                         if (!derivesFromBaseException(subtype)) {
-                            diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                            diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
                                 type: this._evaluator.printType(exceptionType),
                             }));
                         }
                         return types_1.ClassType.cloneAsInstance(subtype);
                     }
-                    diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                    diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
                         type: this._evaluator.printType(exceptionType),
                     }));
                     return types_1.UnknownType.create();
@@ -1974,7 +1980,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (!diagAddendum.isEmpty()) {
-            this._evaluator.addError(localize_1.Localizer.Diagnostic.exceptionTypeNotClass().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.exceptionTypeNotClass().format({
                 type: this._evaluator.printType(exceptionType),
             }), errorNode);
         }
@@ -1991,7 +1997,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         nodes.forEach((node) => {
             if (!moduleScope.symbolTable.has(node.value)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnsupportedDunderAll, diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll, localize_1.Localizer.Diagnostic.dunderAllSymbolNotPresent().format({ name: node.value }), node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll, localize_1.LocMessage.dunderAllSymbolNotPresent().format({ name: node.value }), node);
             }
         });
     }
@@ -2041,7 +2047,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         : [];
                 if (overloadedFunctions.length === 1) {
                     // There should never be a single overload.
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.singleOverload().format({ name }), primaryDecl.node.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, 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.
@@ -2073,7 +2079,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(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadWithoutImplementation().format({
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overloadWithoutImplementation().format({
                                 name: primaryDecl.node.name.value,
                             }), primaryDecl.node.name);
                         }
@@ -2085,12 +2091,12 @@ 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(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadImplementationMismatch().format({
+                                    const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overloadImplementationMismatch().format({
                                         name,
                                         index: index + 1,
                                     }) + diag.getString(), implementationFunction.details.declaration.node.name);
                                     if (diagnostic && overload.details.declaration) {
-                                        diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadSignature(), (_b = (_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.uri) !== null && _b !== void 0 ? _b : primaryDecl.uri, (_d = (_c = overload.details.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
+                                        diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadSignature(), (_b = (_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.uri) !== null && _b !== void 0 ? _b : primaryDecl.uri, (_d = (_c = overload.details.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
                                     }
                                 }
                             }
@@ -2110,7 +2116,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         decls.forEach((decl) => {
             if (this._evaluator.isFinalVariableDeclaration(decl)) {
                 if (sawFinal) {
-                    this._evaluator.addError(localize_1.Localizer.Diagnostic.finalRedeclaration().format({ name }), decl.node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalRedeclaration().format({ name }), decl.node);
                 }
                 sawFinal = true;
             }
@@ -2121,7 +2127,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // the assignment is within an `__init__` method, so ignore class
                     // scopes here.
                     if (scopeType !== 2 /* ScopeType.Class */) {
-                        this._evaluator.addError(localize_1.Localizer.Diagnostic.finalReassigned().format({ name }), decl.node);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), decl.node);
                     }
                 }
                 sawAssignment = true;
@@ -2153,7 +2159,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
                 if (!isImplicitlyAssigned && !isProtocolClass) {
-                    this._evaluator.addError(localize_1.Localizer.Diagnostic.finalUnassigned().format({ name }), firstDecl.node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalUnassigned().format({ name }), firstDecl.node);
                 }
             }
         }
@@ -2165,7 +2171,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (typeAliasDecl && decls.length > 1) {
             decls.forEach((decl) => {
                 if (decl !== typeAliasDecl) {
-                    this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasRedeclared().format({ name }), decl.node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasRedeclared().format({ name }), decl.node);
                 }
             });
         }
@@ -2221,26 +2227,26 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let primaryDeclInfo;
         if (primaryDecl.type === 5 /* DeclarationType.Function */) {
             if (primaryDecl.isMethod) {
-                primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeMethodDeclaration();
+                primaryDeclInfo = localize_1.LocAddendum.seeMethodDeclaration();
             }
             else {
-                primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeFunctionDeclaration();
+                primaryDeclInfo = localize_1.LocAddendum.seeFunctionDeclaration();
             }
         }
         else if (primaryDecl.type === 6 /* DeclarationType.Class */) {
-            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeClassDeclaration();
+            primaryDeclInfo = localize_1.LocAddendum.seeClassDeclaration();
         }
         else if (primaryDecl.type === 2 /* DeclarationType.Parameter */) {
-            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeParameterDeclaration();
+            primaryDeclInfo = localize_1.LocAddendum.seeParameterDeclaration();
         }
         else if (primaryDecl.type === 1 /* DeclarationType.Variable */) {
-            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeVariableDeclaration();
+            primaryDeclInfo = localize_1.LocAddendum.seeVariableDeclaration();
         }
         else if (primaryDecl.type === 4 /* DeclarationType.TypeAlias */) {
-            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeTypeAliasDeclaration();
+            primaryDeclInfo = localize_1.LocAddendum.seeTypeAliasDeclaration();
         }
         else {
-            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeDeclaration();
+            primaryDeclInfo = localize_1.LocAddendum.seeDeclaration();
         }
         const addPrimaryDeclInfo = (diag) => {
             if (diag) {
@@ -2273,7 +2279,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     duplicateIsOk = true;
                 }
                 if (!duplicateIsOk) {
-                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredClassDeclaration().format({ name }), otherDecl.node.name);
+                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.obscuredClassDeclaration().format({ name }), otherDecl.node.name);
                     addPrimaryDeclInfo(diag);
                 }
             }
@@ -2306,9 +2312,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     duplicateIsOk = true;
                 }
                 if (!duplicateIsOk) {
-                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, otherDecl.isMethod
-                        ? localize_1.Localizer.Diagnostic.obscuredMethodDeclaration().format({ name })
-                        : localize_1.Localizer.Diagnostic.obscuredFunctionDeclaration().format({ name }), otherDecl.node.name);
+                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, otherDecl.isMethod
+                        ? localize_1.LocMessage.obscuredMethodDeclaration().format({ name })
+                        : localize_1.LocMessage.obscuredFunctionDeclaration().format({ name }), otherDecl.node.name);
                     addPrimaryDeclInfo(diag);
                 }
             }
@@ -2321,8 +2327,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         duplicateIsOk = true;
                     }
                     if (!duplicateIsOk) {
-                        const message = localize_1.Localizer.Diagnostic.obscuredParameterDeclaration();
-                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name }), otherDecl.node.name);
+                        const message = localize_1.LocMessage.obscuredParameterDeclaration();
+                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name }), otherDecl.node.name);
                         addPrimaryDeclInfo(diag);
                     }
                 }
@@ -2343,14 +2349,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             duplicateIsOk = true;
                         }
                         if (!duplicateIsOk) {
-                            const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredVariableDeclaration().format({ name }), otherDecl.node);
+                            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.obscuredVariableDeclaration().format({ name }), otherDecl.node);
                             addPrimaryDeclInfo(diag);
                         }
                     }
                 }
             }
             else if (otherDecl.type === 4 /* DeclarationType.TypeAlias */) {
-                const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredTypeAliasDeclaration().format({ name }), otherDecl.node.name);
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.obscuredTypeAliasDeclaration().format({ name }), otherDecl.node.name);
                 addPrimaryDeclInfo(diag);
             }
         }
@@ -2404,8 +2410,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const multipartName = nameParts.map((np) => np.value).join('.');
                             let textRange = { start: nameParts[0].start, length: nameParts[0].length };
                             textRange = textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
-                            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unaccessedSymbol().format({ name: multipartName }), textRange, { action: "pyright.unusedImport" /* Commands.unusedImport */ });
-                            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportUnusedImport, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.Localizer.Diagnostic.unaccessedImport().format({ name: multipartName }), textRange);
+                            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: multipartName }), textRange, { action: "pyright.unusedImport" /* Commands.unusedImport */ });
+                            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportUnusedImport, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
                             return;
                         }
                     }
@@ -2423,7 +2429,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
                 if (nameNode) {
-                    message = localize_1.Localizer.Diagnostic.unaccessedImport().format({ name: nameNode.value });
+                    message = localize_1.LocMessage.unaccessedImport().format({ name: nameNode.value });
                 }
                 break;
             case 4 /* DeclarationType.TypeAlias */:
@@ -2453,7 +2459,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 if (nameNode) {
                     rule = diagnosticRules_1.DiagnosticRule.reportUnusedVariable;
-                    message = localize_1.Localizer.Diagnostic.unaccessedVariable().format({ name: nameNode.value });
+                    message = localize_1.LocMessage.unaccessedVariable().format({ name: nameNode.value });
                 }
                 break;
             case 6 /* DeclarationType.Class */:
@@ -2468,7 +2474,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedClass;
                 nameNode = decl.node.name;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedClass;
-                message = localize_1.Localizer.Diagnostic.unaccessedClass().format({ name: nameNode.value });
+                message = localize_1.LocMessage.unaccessedClass().format({ name: nameNode.value });
                 break;
             case 5 /* DeclarationType.Function */:
                 if (!isPrivate) {
@@ -2482,7 +2488,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedFunction;
                 nameNode = decl.node.name;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedFunction;
-                message = localize_1.Localizer.Diagnostic.unaccessedFunction().format({ name: nameNode.value });
+                message = localize_1.LocMessage.unaccessedFunction().format({ name: nameNode.value });
                 break;
             case 3 /* DeclarationType.TypeParameter */:
                 // Never report a diagnostic for an unused TypeParameter.
@@ -2497,9 +2503,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const action = rule === diagnosticRules_1.DiagnosticRule.reportUnusedImport ? { action: "pyright.unusedImport" /* Commands.unusedImport */ } : undefined;
         if (nameNode) {
-            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unaccessedSymbol().format({ name: nameNode.value }), nameNode, action);
-            if (rule !== undefined && message) {
-                this._evaluator.addDiagnostic(diagnosticLevel, rule, message, nameNode);
+            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: nameNode.value }), nameNode, action);
+            if (rule !== undefined && message && diagnosticLevel !== 'none') {
+                this._evaluator.addDiagnostic(rule, message, nameNode);
             }
         }
     }
@@ -2541,11 +2547,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         if (!isValidType) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, isInstanceCheck
-                ? localize_1.Localizer.Diagnostic.isInstanceInvalidType().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, isInstanceCheck
+                ? localize_1.LocMessage.isInstanceInvalidType().format({
                     type: this._evaluator.printType(arg1Type),
                 }) + diag.getString()
-                : localize_1.Localizer.Diagnostic.isSubclassInvalidType().format({
+                : localize_1.LocMessage.isSubclassInvalidType().format({
                     type: this._evaluator.printType(arg1Type),
                 }) + diag.getString(), node.arguments[1]);
         }
@@ -2566,7 +2572,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             });
             if (!diag.isEmpty()) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataProtocolInSubclassCheck(), node.arguments[1]);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataProtocolInSubclassCheck(), node.arguments[1]);
             }
         }
         // If this call is within an assert statement, we won't check whether
@@ -2724,12 +2730,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // If arg1IncludesSubclasses is true, it contains a Type[X] class rather than X. A Type[X]
         // could be a subclass of X, so the "unnecessary isinstance check" may be legit.
         if (!arg1IncludesSubclasses && (0, types_1.isTypeSame)(filteredType, arg0Type, { ignorePseudoGeneric: true })) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryIsInstance, diagnosticRules_1.DiagnosticRule.reportUnnecessaryIsInstance, isInstanceCheck
-                ? localize_1.Localizer.Diagnostic.unnecessaryIsInstanceAlways().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryIsInstance, isInstanceCheck
+                ? localize_1.LocMessage.unnecessaryIsInstanceAlways().format({
                     testType: this._evaluator.printType(arg0Type),
                     classType: this._evaluator.printType(getTestType()),
                 })
-                : localize_1.Localizer.Diagnostic.unnecessaryIsSubclassAlways().format({
+                : localize_1.LocMessage.unnecessaryIsSubclassAlways().format({
                     testType: this._evaluator.printType(arg0Type),
                     classType: this._evaluator.printType(getTestType()),
                 }), node);
@@ -2745,14 +2751,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if ((0, types_1.isClassInstance)(testSubtype)) {
                     if ((0, protocols_1.isProtocolUnsafeOverlap)(this._evaluator, protocol, testSubtype)) {
                         isUnsafeOverlap = true;
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolUnsafeOverlap().format({
+                        diag.addMessage(localize_1.LocAddendum.protocolUnsafeOverlap().format({
                             name: testSubtype.details.name,
                         }));
                     }
                 }
             });
             if (isUnsafeOverlap) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolUnsafeOverlap().format({
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.protocolUnsafeOverlap().format({
                     name: protocol.details.name,
                 }) + diag.getString(), errorNode);
             }
@@ -2766,7 +2772,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
             if (subtype.specialForm && types_1.ClassType.isBuiltIn(subtype.specialForm, 'TypeAliasType')) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAliasInstanceCheck());
+                diag.addMessage(localize_1.LocAddendum.typeAliasInstanceCheck());
                 isSupported = false;
                 return;
             }
@@ -2777,17 +2783,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     break;
                 case 6 /* TypeCategory.Class */:
                     if ((0, typeUtils_1.isNoneInstance)(subtype)) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.noneNotAllowed());
+                        diag.addMessage(localize_1.LocAddendum.noneNotAllowed());
                         isSupported = false;
                     }
                     else if (types_1.ClassType.isTypedDictClass(subtype)) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictClassNotAllowed());
+                        diag.addMessage(localize_1.LocAddendum.typedDictClassNotAllowed());
                         isSupported = false;
                     }
                     else if (subtype.isTypeArgumentExplicit && !subtype.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.Localizer.DiagnosticAddendum.genericClassNotAllowed());
+                        diag.addMessage(localize_1.LocAddendum.genericClassNotAllowed());
                         isSupported = false;
                     }
                     else if (types_1.ClassType.isProtocolClass(subtype) &&
@@ -2796,22 +2802,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // According to PEP 544, protocol classes cannot be used as the right-hand
                         // argument to isinstance or issubclass unless they are annotated as
                         // "runtime checkable".
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolRequiresRuntimeCheckable());
+                        diag.addMessage(localize_1.LocAddendum.protocolRequiresRuntimeCheckable());
                         isSupported = false;
                     }
                     else if (types_1.ClassType.isNewTypeClass(subtype)) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.newTypeClassNotAllowed());
+                        diag.addMessage(localize_1.LocAddendum.newTypeClassNotAllowed());
                         isSupported = false;
                     }
                     break;
                 case 4 /* TypeCategory.Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.genericClassNotAllowed());
+                        diag.addMessage(localize_1.LocAddendum.genericClassNotAllowed());
                         isSupported = false;
                     }
                     break;
                 case 9 /* TypeCategory.TypeVar */:
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarNotAllowed());
+                    diag.addMessage(localize_1.LocAddendum.typeVarNotAllowed());
                     isSupported = false;
                     break;
             }
@@ -2820,7 +2826,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validateNotDataProtocol(type, diag) {
         if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isProtocolClass(type) && !(0, protocols_1.isMethodOnlyProtocol)(type)) {
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.dataProtocolUnsupported().format({
+            diag.addMessage(localize_1.LocAddendum.dataProtocolUnsupported().format({
                 name: type.details.name,
             }));
         }
@@ -2847,30 +2853,30 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             !types_1.ClassType.isClassProperty(functionTypeResult.decoratedType)) {
             return;
         }
-        this._reportDeprecatedDiagnostic(node.name, localize_1.Localizer.Diagnostic.classPropertyDeprecated());
+        this._reportDeprecatedDiagnostic(node.name, localize_1.LocMessage.classPropertyDeprecated());
     }
     _reportDeprecatedUseForMemberAccess(node, info) {
         let errorMessage;
         if (info.accessType === 'property') {
             if (info.accessMethod === 'get') {
-                errorMessage = localize_1.Localizer.Diagnostic.deprecatedPropertyGetter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedPropertyGetter().format({ name: node.value });
             }
             else if (info.accessMethod === 'set') {
-                errorMessage = localize_1.Localizer.Diagnostic.deprecatedPropertySetter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedPropertySetter().format({ name: node.value });
             }
             else {
-                errorMessage = localize_1.Localizer.Diagnostic.deprecatedPropertyDeleter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedPropertyDeleter().format({ name: node.value });
             }
         }
         else if (info.accessType === 'descriptor') {
             if (info.accessMethod === 'get') {
-                errorMessage = localize_1.Localizer.Diagnostic.deprecatedDescriptorGetter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedDescriptorGetter().format({ name: node.value });
             }
             else if (info.accessMethod === 'set') {
-                errorMessage = localize_1.Localizer.Diagnostic.deprecatedDescriptorSetter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedDescriptorSetter().format({ name: node.value });
             }
             else {
-                errorMessage = localize_1.Localizer.Diagnostic.deprecatedDescriptorDeleter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedDescriptorDeleter().format({ name: node.value });
             }
         }
         if (errorMessage) {
@@ -2890,13 +2896,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const containingClass = ParseTreeUtils.getEnclosingClass(functionType.details.declaration.node, 
                 /* stopAtFunction */ true);
                 if (containingClass) {
-                    return localize_1.Localizer.Diagnostic.deprecatedMethod().format({
+                    return localize_1.LocMessage.deprecatedMethod().format({
                         name: functionType.details.name || '<anonymous>',
                         className: containingClass.name.value,
                     });
                 }
             }
-            return localize_1.Localizer.Diagnostic.deprecatedFunction().format({
+            return localize_1.LocMessage.deprecatedFunction().format({
                 name: functionType.details.name,
             });
         }
@@ -2927,7 +2933,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         else if ((0, types_1.isInstantiableClass)(type) && overload.details.name === '__init__') {
                             deprecatedMessage = overload.details.deprecatedMessage;
-                            errorMessage = localize_1.Localizer.Diagnostic.deprecatedConstructor().format({
+                            errorMessage = localize_1.LocMessage.deprecatedConstructor().format({
                                 name: type.details.name,
                             });
                         }
@@ -2941,7 +2947,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     subtype.details.deprecatedMessage !== undefined &&
                     node.value === subtype.details.name) {
                     deprecatedMessage = subtype.details.deprecatedMessage;
-                    errorMessage = localize_1.Localizer.Diagnostic.deprecatedClass().format({ name: subtype.details.name });
+                    errorMessage = localize_1.LocMessage.deprecatedClass().format({ name: subtype.details.name });
                 }
                 else {
                     // See if this is part of a call to a constructor.
@@ -2984,13 +2990,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (this._fileInfo.executionEnvironment.pythonVersion >= deprecatedForm.version) {
                         if (!deprecatedForm.typingImportOnly || isImportFromTyping) {
                             if (this._fileInfo.diagnosticRuleSet.reportDeprecated === 'none') {
-                                this._evaluator.addDeprecated(localize_1.Localizer.Diagnostic.deprecatedType().format({
+                                this._evaluator.addDeprecated(localize_1.LocMessage.deprecatedType().format({
                                     version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
                                     replacement: deprecatedForm.replacementText,
                                 }), node);
                             }
                             else {
-                                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDeprecated, diagnosticRules_1.DiagnosticRule.reportDeprecated, localize_1.Localizer.Diagnostic.deprecatedType().format({
+                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDeprecated, localize_1.LocMessage.deprecatedType().format({
                                     version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
                                     replacement: deprecatedForm.replacementText,
                                 }), node);
@@ -3010,7 +3016,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDeprecated(diagnosticMessage + diag.getString(), node);
         }
         else {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDeprecated, diagnosticRules_1.DiagnosticRule.reportDeprecated, diagnosticMessage + diag.getString(), node);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDeprecated, diagnosticMessage + diag.getString(), node);
         }
     }
     _reportUnboundName(node) {
@@ -3021,10 +3027,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const type = this._evaluator.getType(node);
             if (type) {
                 if ((0, types_1.isUnbound)(type)) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnboundVariable, diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.Localizer.Diagnostic.symbolIsUnbound().format({ name: node.value }), 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(this._fileInfo.diagnosticRuleSet.reportUnboundVariable, diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.Localizer.Diagnostic.symbolIsPossiblyUnbound().format({ name: node.value }), node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.LocMessage.symbolIsPossiblyUnbound().format({ name: node.value }), node);
                 }
             }
         }
@@ -3045,7 +3051,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._importResolver.isStdlibModule(desc, this._fileInfo.executionEnvironment) &&
             this._sourceMapper.isUserCode(this._fileInfo.fileUri)) {
             // This means the user has a module that is overwriting the stdlib module.
-            const diag = this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.Localizer.Diagnostic.stdlibModuleOverridden().format({
+            const diag = this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.LocMessage.stdlibModuleOverridden().format({
                 name: moduleName,
                 path: this._fileInfo.fileUri.toUserVisibleString(),
             }), this._moduleNode);
@@ -3096,7 +3102,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             paths.forEach((p) => {
                 if (!p.startsWith(stdlibPath) && !(0, sourceMapper_1.isStubFile)(p) && this._sourceMapper.isUserCode(p)) {
                     // This means the user has a module that is overwriting the stdlib module.
-                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.Localizer.Diagnostic.stdlibModuleOverridden().format({
+                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.LocMessage.stdlibModuleOverridden().format({
                         name: nameParts.join('.'),
                         path: p.toUserVisibleString(),
                     }), node);
@@ -3200,10 +3206,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (classNode && !ParseTreeUtils.isNodeContainedWithin(node, classNode)) {
             if (isProtectedAccess) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportPrivateUsage, diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.Localizer.Diagnostic.protectedUsedOutsideOfClass().format({ name: nameValue }), node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.LocMessage.protectedUsedOutsideOfClass().format({ name: nameValue }), node);
             }
             else {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportPrivateUsage, diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.Localizer.Diagnostic.privateUsedOutsideOfClass().format({ name: nameValue }), node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.LocMessage.privateUsedOutsideOfClass().format({ name: nameValue }), node);
             }
         }
     }
@@ -3211,18 +3217,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // enum class that has already defined values.
     _validateEnumClassOverride(node, classType) {
         classType.details.baseClasses.forEach((baseClass, index) => {
-            if ((0, types_1.isClass)(baseClass) && types_1.ClassType.isEnumClass(baseClass)) {
-                // Determine whether the base enum class defines an enumerated value.
-                let baseEnumDefinesValue = false;
-                baseClass.details.fields.forEach((symbol) => {
-                    const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
-                    if ((0, types_1.isClassInstance)(symbolType) && types_1.ClassType.isSameGenericClass(symbolType, baseClass)) {
-                        baseEnumDefinesValue = true;
-                    }
-                });
-                if (baseEnumDefinesValue) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.enumClassOverride().format({ name: baseClass.details.name }), node.arguments[index]);
-                }
+            if ((0, types_1.isClass)(baseClass) && (0, enums_1.isEnumClassWithMembers)(this._evaluator, baseClass)) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.enumClassOverride().format({ name: baseClass.details.name }), node.arguments[index]);
             }
         });
     }
@@ -3231,7 +3227,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // strings, and "pass" statements or ellipses.
     _validateTypedDictClassSuite(suiteNode) {
         const emitBadStatementError = (node) => {
-            this._evaluator.addError(localize_1.Localizer.Diagnostic.typedDictBadVar(), node);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBadVar(), node);
         };
         suiteNode.statements.forEach((statement) => {
             if (!AnalyzerNodeInfo.isCodeUnreachable(statement)) {
@@ -3272,7 +3268,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (paramCount < 1) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeGuardParamCount(), node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeGuardParamCount(), node.name);
         }
     }
     _validateDunderSignatures(node, functionType, isMethod) {
@@ -3284,7 +3280,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const declaredReturnType = functionType.details.declaredReturnType;
             if (returnAnnotation && declaredReturnType) {
                 if (!(0, typeUtils_1.isNoneInstance)(declaredReturnType) && !(0, types_1.isNever)(declaredReturnType)) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initMustReturnNone(), returnAnnotation);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initMustReturnNone(), returnAnnotation);
                 }
             }
             else {
@@ -3292,7 +3288,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!(0, types_1.isNever)(inferredReturnType) &&
                     !(0, typeUtils_1.isNoneInstance)(inferredReturnType) &&
                     !(0, types_1.isAnyOrUnknown)(inferredReturnType)) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initMustReturnNone(), node.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initMustReturnNone(), node.name);
                 }
             }
         }
@@ -3328,7 +3324,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(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnReturnsNone(), returnAnnotation);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnReturnsNone(), returnAnnotation);
                     }
                 }
                 else if (!types_1.FunctionType.isAbstractMethod(functionType)) {
@@ -3341,7 +3337,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(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnMissing().format({
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnMissing().format({
                                 returnType: this._evaluator.printType(declaredReturnType),
                             }) + diagAddendum.getString(), returnAnnotation);
                         }
@@ -3358,20 +3354,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateReturnTypeIsNotContravariant(returnType, errorNode) {
         let isContraTypeVar = false;
         (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
-            if ((0, types_1.isTypeVar)(subtype) && subtype.details.declaredVariance === 4 /* Variance.Contravariant */) {
+            if ((0, types_1.isTypeVar)(subtype) &&
+                subtype.details.declaredVariance === 4 /* Variance.Contravariant */ &&
+                subtype.scopeType === 0 /* TypeVarScopeType.Class */) {
                 isContraTypeVar = true;
             }
         });
         if (isContraTypeVar) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeContravariant(), errorNode);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnTypeContravariant(), errorNode);
         }
     }
     _reportUnknownReturnResult(node, returnType) {
         if ((0, types_1.isUnknown)(returnType)) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypeUnknown(), node.name);
         }
         else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypePartiallyUnknown().format({
                 returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
             }), node.name);
         }
@@ -3386,94 +3384,83 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._evaluator.isFinalVariable(parentSymbol.symbol) &&
                 !SymbolNameUtils.isPrivateName(name)) {
                 const decl = localSymbol.getDeclarations()[0];
-                this._evaluator.addError(localize_1.Localizer.Diagnostic.finalRedeclarationBySubclass().format({
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalRedeclarationBySubclass().format({
                     name,
                     className: parentSymbol.classType.details.name,
                 }), decl.node);
             }
         });
     }
-    _reportDuplicateEnumMembers(classType) {
+    // Validates that the values associated with enum members are type compatible.
+    // Also looks for duplicate values.
+    _validateEnumMembers(classType, node) {
         if (!types_1.ClassType.isEnumClass(classType) || types_1.ClassType.isBuiltIn(classType)) {
             return;
         }
+        // Does the "_value_" field have a declared type? If so, we'll enforce it.
+        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 */);
         classType.details.fields.forEach((symbol, name) => {
+            var _a;
             // Enum members don't have type annotations.
             if (symbol.getTypedDeclarations().length > 0) {
                 return;
             }
+            const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+            // Is this symbol a literal instance of the enum class?
+            if (!(0, types_1.isClassInstance)(symbolType) ||
+                !types_1.ClassType.isSameGenericClass(symbolType, classType) ||
+                !(symbolType.literalValue instanceof types_1.EnumLiteral)) {
+                return;
+            }
+            // Look for a duplicate assignment.
             const decls = symbol.getDeclarations();
             if (decls.length >= 2 && decls[0].type === 1 /* DeclarationType.Variable */) {
-                const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
-                // Is this symbol a literal instance of the enum class?
-                if ((0, types_1.isClassInstance)(symbolType) &&
-                    types_1.ClassType.isSameGenericClass(symbolType, classType) &&
-                    symbolType.literalValue !== undefined) {
-                    this._evaluator.addError(localize_1.Localizer.Diagnostic.duplicateEnumMember().format({ name }), decls[1].node);
-                }
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.duplicateEnumMember().format({ name }), decls[1].node);
+                return;
             }
-        });
-    }
-    // If a non-protocol class explicitly inherits from a protocol class and does
-    // not explicit derive from ABC, this method verifies that any class or instance
-    // variables declared but not assigned in the protocol class are implemented in
-    // the subclass. It also checks that any empty functions declared in the protocol
-    // are implemented in the subclass.
-    _validateProtocolCompatibility(classType, errorNode) {
-        if (types_1.ClassType.isProtocolClass(classType)) {
-            return;
-        }
-        // If a class derives from ABC, exempt it from this check. This is used for
-        // mixins that derive from a protocol but do not directly implement all
-        // of the protocol's methods.
-        if (classType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'ABC'))) {
-            return;
-        }
-        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-        const isSymbolImplemented = (name) => {
-            return classType.details.mro.some((mroClass) => {
-                return (0, types_1.isClass)(mroClass) && !types_1.ClassType.isProtocolClass(mroClass) && mroClass.details.fields.has(name);
-            });
-        };
-        classType.details.baseClasses.forEach((baseClass) => {
-            if (!(0, types_1.isClass)(baseClass) || !types_1.ClassType.isProtocolClass(baseClass)) {
+            if (decls[0].type !== 1 /* DeclarationType.Variable */) {
                 return;
             }
-            const protocolSymbols = (0, typeUtils_1.getProtocolSymbols)(baseClass);
-            protocolSymbols.forEach((member, name) => {
-                const decls = member.symbol.getDeclarations();
-                if (decls.length === 0 || !(0, types_1.isClass)(member.classType)) {
-                    return;
-                }
-                if (decls[0].type === 1 /* DeclarationType.Variable */) {
-                    // If none of the declarations involve assignments, assume it's
-                    // not implemented in the protocol.
-                    if (!decls.some((decl) => decl.type === 1 /* DeclarationType.Variable */ && !!decl.inferredTypeSource)) {
-                        // This is a variable declaration that is not implemented in the
-                        // protocol base class. Make sure it's implemented in the derived class.
-                        if (!isSymbolImplemented(name)) {
-                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
-                                name,
-                                classType: member.classType.details.name,
-                            }));
-                        }
+            const declNode = decls[0].node;
+            const assignedValueType = symbolType.literalValue.itemType;
+            const assignmentNode = ParseTreeUtils.getParentNodeOfType(declNode, 3 /* ParseNodeType.Assignment */);
+            const errorNode = (_a = assignmentNode === null || assignmentNode === void 0 ? void 0 : assignmentNode.rightExpression) !== null && _a !== void 0 ? _a : declNode;
+            // Validate the __new__ and __init__ methods if present.
+            if (newMemberTypeResult || initMemberTypeResult) {
+                if (!(0, types_1.isAnyOrUnknown)(assignedValueType)) {
+                    // Construct an argument list. If the assigned type is a tuple, we'll
+                    // 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 */,
+                            typeResult: { type: assignedValueType },
+                        },
+                    ];
+                    if (newMemberTypeResult) {
+                        this._evaluator.validateCallArguments(errorNode, argList, newMemberTypeResult);
+                    }
+                    if (initMemberTypeResult) {
+                        this._evaluator.validateCallArguments(errorNode, argList, initMemberTypeResult);
                     }
                 }
-                else if (decls[0].type === 5 /* DeclarationType.Function */) {
-                    if (this._isUnimplementedProtocolMethod(member.symbol)) {
-                        if (!isSymbolImplemented(name)) {
-                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
-                                name,
-                                classType: member.classType.details.name,
-                            }));
-                        }
+            }
+            else if (declaredValueType) {
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                // If the assigned value is already an instance of this enum class, skip this check.
+                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);
                     }
                 }
-            });
+            }
         });
-        if (!diagAddendum.isEmpty()) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.missingProtocolMembers() + diagAddendum.getString(), errorNode.name);
-        }
     }
     // If a class is a dataclass with a `__post_init__` method, verify that its
     // signature is correct.
@@ -3520,7 +3507,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // We expect to see one param for "self" plus one for each of the InitVars.
         const expectedParamCount = initOnlySymbolMap.size + 1;
         if (expectedParamCount < nonDefaultParams.length || expectedParamCount > paramListDetails.params.length) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassPostInitParamCount().format({ expected: initOnlySymbolMap.size }), postInitType.details.declaration.node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitParamCount().format({ expected: initOnlySymbolMap.size }), postInitType.details.declaration.node.name);
         }
         // Verify that the parameter types match.
         let paramIndex = 1;
@@ -3535,11 +3522,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const paramType = types_1.FunctionType.getEffectiveParameterType(postInitType, paramListDetails.params[paramIndex].index);
                 const assignTypeDiag = new diagnostic_1.DiagnosticAddendum();
                 if (fieldType && !this._evaluator.assignType(paramType, fieldType, assignTypeDiag)) {
-                    const diagnostic = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassPostInitType().format({ fieldName }) + assignTypeDiag.getString(), param.typeAnnotation);
+                    const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitType().format({ fieldName }) + assignTypeDiag.getString(), param.typeAnnotation);
                     if (diagnostic) {
                         const fieldDecls = symbol.getTypedDeclarations();
                         if (fieldDecls.length > 0) {
-                            diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.dataClassFieldLocation(), fieldDecls[0].uri, fieldDecls[0].range);
+                            diagnostic.addRelatedInfo(localize_1.LocAddendum.dataClassFieldLocation(), fieldDecls[0].uri, fieldDecls[0].range);
                         }
                     }
                 }
@@ -3547,42 +3534,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             paramIndex++;
         });
     }
-    // Determine whether a method defined in a protocol should be considered
-    // "unimplemented". This is an under-specified part of the typing spec.
-    _isUnimplementedProtocolMethod(symbol) {
-        const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
-        // Behavior differs between stub files and source files.
-        const decls = symbol.getDeclarations();
-        const isDeclaredInStubFile = decls.length > 0 && (0, sourceMapper_1.isStubFile)(decls[0].uri);
-        if ((0, types_1.isFunction)(symbolType)) {
-            const decl = symbolType.details.declaration;
-            if (decl) {
-                return isDeclaredInStubFile
-                    ? types_1.FunctionType.isAbstractMethod(symbolType)
-                    : ParseTreeUtils.isSuiteEmpty(decl.node.suite);
-            }
-        }
-        else if ((0, types_1.isOverloadedFunction)(symbolType)) {
-            // If an implementation is present and has an empty body, assume
-            // the function is unimplemented.
-            const impl = types_1.OverloadedFunctionType.getImplementation(symbolType);
-            if (impl) {
-                const decl = impl.details.declaration;
-                if (decl) {
-                    return ParseTreeUtils.isSuiteEmpty(decl.node.suite);
-                }
-                return false;
-            }
-            if (isDeclaredInStubFile) {
-                // If no implementation was present, see if any of the overloads
-                // are marked as abstract.
-                const overloads = types_1.OverloadedFunctionType.getOverloads(symbolType);
-                return overloads.some((overload) => types_1.FunctionType.isAbstractMethod(overload));
-            }
-            return true;
-        }
-        return false;
-    }
     // If a class is marked final, it must implement all abstract methods,
     // otherwise it is of no use.
     _validateFinalClassNotAbstract(classType, errorNode) {
@@ -3592,29 +3543,29 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!types_1.ClassType.supportsAbstractMethods(classType)) {
             return;
         }
-        const abstractMethods = this._evaluator.getAbstractMethods(classType);
-        if (abstractMethods.length === 0) {
+        const abstractSymbols = this._evaluator.getAbstractSymbols(classType);
+        if (abstractSymbols.length === 0) {
             return;
         }
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         const errorsToDisplay = 2;
-        abstractMethods.forEach((abstractMethod, index) => {
+        abstractSymbols.forEach((abstractMethod, index) => {
             if (index === errorsToDisplay) {
-                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsAbstractMore().format({
-                    count: abstractMethods.length - errorsToDisplay,
+                diagAddendum.addMessage(localize_1.LocAddendum.memberIsAbstractMore().format({
+                    count: abstractSymbols.length - errorsToDisplay,
                 }));
             }
             else if (index < errorsToDisplay) {
                 if ((0, types_1.isInstantiableClass)(abstractMethod.classType)) {
                     const className = abstractMethod.classType.details.name;
-                    diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsAbstract().format({
+                    diagAddendum.addMessage(localize_1.LocAddendum.memberIsAbstract().format({
                         type: className,
                         name: abstractMethod.symbolName,
                     }));
                 }
             }
         });
-        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.finalClassIsAbstract().format({
+        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalClassIsAbstract().format({
             type: classType.details.name,
         }) + diagAddendum.getString(), errorNode.name);
     }
@@ -3693,7 +3644,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             // Report the variable as uninitialized only on the first decl.
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUninitializedInstanceVariable, diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.Localizer.Diagnostic.uninitializedInstanceVariable().format({ name: name }), decls[0].node);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.LocMessage.uninitializedInstanceVariable().format({ name: name }), decls[0].node);
         });
         // See if there are any variables from abstract base classes
         // that are not initialized.
@@ -3709,7 +3660,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!decls.some((decl) => decl.type === 1 /* DeclarationType.Variable */ && !!decl.inferredTypeSource)) {
                     // This is a variable declaration that is not implemented in the
                     // protocol base class. Make sure it's implemented in the derived class.
-                    diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.uninitializedAbstractVariable().format({
+                    diagAddendum.addMessage(localize_1.LocAddendum.uninitializedAbstractVariable().format({
                         name,
                         classType: member.classType.details.name,
                     }));
@@ -3717,7 +3668,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         if (!diagAddendum.isEmpty()) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUninitializedInstanceVariable, diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.Localizer.Diagnostic.uninitializedAbstractVariables().format({ classType: classType.details.name }) +
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.LocMessage.uninitializedAbstractVariables().format({ classType: classType.details.name }) +
                 diagAddendum.getString(), node.name);
         }
     }
@@ -3733,12 +3684,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!(0, types_1.isInstantiableClass)(objectType)) {
             return;
         }
-        // Replace all of the type parameters with invariant TypeVars.
-        const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
-        const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
         const objectObject = types_1.ClassType.cloneAsInstance(objectType);
         const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
-        updatedTypeParams.forEach((param, paramIndex) => {
+        classType.details.typeParameters.forEach((param, paramIndex) => {
             // Skip variadics and ParamSpecs.
             if (param.details.isVariadic || param.details.isParamSpec) {
                 return;
@@ -3749,7 +3697,7 @@ 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 = updatedTypeParams.map((p, i) => {
+            const srcTypeArgs = classType.details.typeParameters.map((p, i) => {
                 if (p.details.isVariadic) {
                     return p;
                 }
@@ -3757,20 +3705,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 itself.
-            const destTypeArgs = updatedTypeParams.map((p, i) => {
+            const destTypeArgs = classType.details.typeParameters.map((p, i) => {
                 return i === paramIndex || p.details.isVariadic ? p : dummyTypeObject;
             });
-            const srcType = types_1.ClassType.cloneForSpecialization(updatedClassType, srcTypeArgs, 
-            /* isTypeArgumentExplicit */ true);
-            const destType = types_1.ClassType.cloneForSpecialization(updatedClassType, destTypeArgs, 
+            const srcType = types_1.ClassType.cloneForSpecialization(classType, srcTypeArgs, /* isTypeArgumentExplicit */ true);
+            const destType = types_1.ClassType.cloneForSpecialization(classType, destTypeArgs, 
             /* isTypeArgumentExplicit */ true);
-            const isDestSubtypeOfSrc = this._evaluator.assignClassToSelf(srcType, destType);
+            const isDestSubtypeOfSrc = this._evaluator.assignClassToSelf(srcType, destType, 3 /* Variance.Covariant */);
             let expectedVariance;
             if (isDestSubtypeOfSrc) {
                 expectedVariance = 3 /* Variance.Covariant */;
             }
             else {
-                const isSrcSubtypeOfDest = this._evaluator.assignClassToSelf(destType, srcType);
+                const isSrcSubtypeOfDest = this._evaluator.assignClassToSelf(destType, srcType, 4 /* Variance.Contravariant */);
                 if (isSrcSubtypeOfDest) {
                     expectedVariance = 4 /* Variance.Contravariant */;
                 }
@@ -3781,24 +3728,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (expectedVariance !== classType.details.typeParameters[paramIndex].details.declaredVariance) {
                 let message;
                 if (expectedVariance === 3 /* Variance.Covariant */) {
-                    message = localize_1.Localizer.Diagnostic.protocolVarianceCovariant().format({
+                    message = localize_1.LocMessage.protocolVarianceCovariant().format({
                         variable: param.details.name,
                         class: classType.details.name,
                     });
                 }
                 else if (expectedVariance === 4 /* Variance.Contravariant */) {
-                    message = localize_1.Localizer.Diagnostic.protocolVarianceContravariant().format({
+                    message = localize_1.LocMessage.protocolVarianceContravariant().format({
                         variable: param.details.name,
                         class: classType.details.name,
                     });
                 }
                 else {
-                    message = localize_1.Localizer.Diagnostic.protocolVarianceInvariant().format({
+                    message = localize_1.LocMessage.protocolVarianceInvariant().format({
                         variable: param.details.name,
                         class: classType.details.name,
                     });
                 }
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, message, errorNode.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, message, errorNode.name);
             }
         });
     }
@@ -3823,7 +3770,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         !decl.isDefinedBySlots &&
                         !decl.isDefinedByMemberAccess) {
                         if (decl.node.nodeType === 38 /* ParseNodeType.Name */ && ParseTreeUtils.isWriteAccess(decl.node)) {
-                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.slotsClassVarConflict().format({ name }), decl.node);
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.slotsClassVarConflict().format({ name }), decl.node);
                         }
                     }
                 });
@@ -3910,20 +3857,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const initSignature = this._evaluator.printType(initMemberType);
                 const newSignature = this._evaluator.printType(newMemberType);
-                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.initMethodSignature().format({
+                diagAddendum.addMessage(localize_1.LocAddendum.initMethodSignature().format({
                     type: initSignature,
                 }));
-                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.newMethodSignature().format({
+                diagAddendum.addMessage(localize_1.LocAddendum.newMethodSignature().format({
                     type: newSignature,
                 }));
-                const diagnostic = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInconsistentConstructor, diagnosticRules_1.DiagnosticRule.reportInconsistentConstructor, localize_1.Localizer.Diagnostic.constructorParametersMismatch().format({
+                const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentConstructor, localize_1.LocMessage.constructorParametersMismatch().format({
                     classType: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? initMethodResult.classType : newMethodResult.classType)),
                 }) + diagAddendum.getString(), mainDeclNode);
                 if (diagnostic) {
                     const secondaryDecl = displayOnInit ? newDecl : initDecl;
-                    diagnostic.addRelatedInfo((displayOnInit
-                        ? localize_1.Localizer.DiagnosticAddendum.newMethodLocation()
-                        : localize_1.Localizer.DiagnosticAddendum.initMethodLocation()).format({
+                    diagnostic.addRelatedInfo((displayOnInit ? localize_1.LocAddendum.newMethodLocation() : localize_1.LocAddendum.initMethodLocation()).format({
                         type: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? newMethodResult.classType : initMethodResult.classType)),
                     }), secondaryDecl.uri, secondaryDecl.range);
                 }
@@ -3963,13 +3908,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const diag = new diagnostic_1.DiagnosticAddendum();
                             const baseClassObject = (0, typeUtils_1.convertToInstance)(baseClass);
                             if ((0, types_1.isTypeSame)(baseClassObject, baseClassMroObject)) {
-                                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.baseClassIncompatible().format({
+                                diag.addMessage(localize_1.LocAddendum.baseClassIncompatible().format({
                                     baseClass: this._evaluator.printType(baseClassObject),
                                     type: this._evaluator.printType(matchingMroObject),
                                 }));
                             }
                             else {
-                                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.baseClassIncompatibleSubclass().format({
+                                diag.addMessage(localize_1.LocAddendum.baseClassIncompatibleSubclass().format({
                                     baseClass: this._evaluator.printType(baseClassObject),
                                     subclass: this._evaluator.printType(baseClassMroObject),
                                     type: this._evaluator.printType(matchingMroObject),
@@ -3984,8 +3929,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (!diagAddendum.isEmpty()) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.baseClassIncompatible().format({ type: classType.details.name }) +
-                diagAddendum.getString(), errorNode);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.baseClassIncompatible().format({ type: classType.details.name }) + diagAddendum.getString(), errorNode);
         }
     }
     // Validates that any methods and variables in multiple base classes are
@@ -4090,7 +4034,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 /* enforceParamNameMatch */ true)) {
                     const decl = overrideFunction.details.declaration;
                     if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                        diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.baseClassMethodTypeIncompatible().format({
+                        diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.baseClassMethodTypeIncompatible().format({
                             classType: childClassType.details.name,
                             name: memberName,
                         }) + diagAddendum.getString(), errorNode);
@@ -4103,7 +4047,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!(0, typeUtils_1.isProperty)(overrideType) && !(0, types_1.isAnyOrUnknown)(overrideType)) {
                 const decls = overrideSymbol.getDeclarations();
                 if (decls.length > 0) {
-                    diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.baseClassVariableTypeIncompatible().format({
+                    diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
                         classType: childClassType.details.name,
                         name: memberName,
                     }), errorNode);
@@ -4149,7 +4093,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     /* diag */ undefined, 
                     /* destTypeVarContext */ undefined, 
                     /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
-                        diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.baseClassVariableTypeIncompatible().format({
+                        diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
                             classType: childClassType.details.name,
                             name: memberName,
                         }), errorNode);
@@ -4168,12 +4112,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         if (!isRequiredCompatible) {
                             const message = overrideTDEntry.isRequired
-                                ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
-                                : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
-                            diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, message().format({ name: memberName }), errorNode);
+                                ? 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(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
+                            diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
                                 name: memberName,
                             }), errorNode);
                         }
@@ -4182,11 +4126,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (diag && overrideDecl && overriddenDecl) {
-            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassOverriddenType().format({
+            diag.addRelatedInfo(localize_1.LocAddendum.baseClassOverriddenType().format({
                 baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(overriddenClassAndSymbol.classType)),
                 type: this._evaluator.printType(overriddenType),
             }), overriddenDecl.uri, overriddenDecl.range);
-            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassOverridesType().format({
+            diag.addRelatedInfo(localize_1.LocAddendum.baseClassOverridesType().format({
                 baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(overrideClassAndSymbol.classType)),
                 type: this._evaluator.printType(overrideType),
             }), overrideDecl.uri, overrideDecl.range);
@@ -4216,7 +4160,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(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadFinalInconsistencyImpl().format({
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, 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);
                         }
@@ -4228,7 +4172,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(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadFinalInconsistencyNoImpl().format({
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, 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);
@@ -4318,7 +4262,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const funcNode = overrideFunction.details.declaration.node;
-        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportImplicitOverride, diagnosticRules_1.DiagnosticRule.reportImplicitOverride, localize_1.Localizer.Diagnostic.overrideDecoratorMissing().format({
+        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportImplicitOverride, localize_1.LocMessage.overrideDecoratorMissing().format({
             name: funcNode.name.value,
             className: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseMember.classType)),
         }), funcNode.name);
@@ -4353,7 +4297,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const funcNode = overrideFunction.details.declaration.node;
-        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overriddenMethodNotFound().format({ name: funcNode.name.value }), funcNode.name);
+        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overriddenMethodNotFound().format({ name: funcNode.name.value }), funcNode.name);
     }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -4395,13 +4339,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (reportFinalMethodOverride) {
                 const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
                 if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                    const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
+                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
                         name: memberName,
                         className: baseClass.details.name,
                     }), decl.node.name);
                     const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                     if (diag && origDecl) {
-                        diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.finalMethod(), origDecl.uri, origDecl.range);
+                        diag.addRelatedInfo(localize_1.LocAddendum.finalMethod(), origDecl.uri, origDecl.range);
                     }
                 }
             }
@@ -4422,13 +4366,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             ? overrideType.details.declaration
                             : (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
                         if (decl) {
-                            const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.incompatibleMethodOverride().format({
+                            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.incompatibleMethodOverride().format({
                                 name: memberName,
                                 className: baseClass.details.name,
                             }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
-                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
+                                diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                             }
                         }
                     }
@@ -4442,14 +4386,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const decls = overrideSymbol.getDeclarations();
                     if (decls.length > 0) {
                         const lastDecl = decls[decls.length - 1];
-                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.methodOverridden().format({
+                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.methodOverridden().format({
                             name: memberName,
                             className: baseClass.details.name,
                             type: this._evaluator.printType(overrideType),
                         }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
-                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
+                            diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                         }
                     }
                 }
@@ -4461,7 +4405,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const decls = overrideSymbol.getDeclarations();
                 if (decls.length > 0) {
                     const lastDecl = decls[decls.length - 1];
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                         name: memberName,
                         className: baseClass.details.name,
                     }), (_c = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _c !== void 0 ? _c : lastDecl.node);
@@ -4486,19 +4430,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if ((0, types_1.isFunction)(baseClassMethodType)) {
                             if (!subclassPropMethod) {
                                 // The method is missing.
-                                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMethodMissing().format({
+                                diagAddendum.addMessage(localize_1.LocAddendum.propertyMethodMissing().format({
                                     name: methodName,
                                 }));
                                 const decls = overrideSymbol.getDeclarations();
                                 if (decls.length > 0) {
                                     const lastDecl = decls[decls.length - 1];
-                                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
+                                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                                         name: memberName,
                                         className: baseClassType.details.name,
                                     }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
                                     const origDecl = baseClassMethodType.details.declaration;
                                     if (diag && origDecl) {
-                                        diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
+                                        diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                                     }
                                 }
                             }
@@ -4506,18 +4450,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType);
                                 if ((0, types_1.isFunction)(subclassMethodType)) {
                                     if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, childClassType, diagAddendum.createAddendum())) {
-                                        diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMethodIncompatible().format({
+                                        diagAddendum.addMessage(localize_1.LocAddendum.propertyMethodIncompatible().format({
                                             name: methodName,
                                         }));
                                         const decl = subclassMethodType.details.declaration;
                                         if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                                            const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
+                                            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                                                 name: memberName,
                                                 className: baseClassType.details.name,
                                             }) + diagAddendum.getString(), decl.node.name);
                                             const origDecl = baseClassMethodType.details.declaration;
                                             if (diag && origDecl) {
-                                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
+                                                diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                                             }
                                         }
                                     }
@@ -4564,19 +4508,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                         if (isInvariant) {
                             diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideIsInvariant());
-                            diagAddendum.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.overrideInvariantMismatch().format({
+                            diagAddendum.addMessage(localize_1.LocAddendum.overrideIsInvariant());
+                            diagAddendum.createAddendum().addMessage(localize_1.LocAddendum.overrideInvariantMismatch().format({
                                 overrideType: this._evaluator.printType(overrideType),
                                 baseType: this._evaluator.printType(baseType),
                             }));
                         }
-                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.symbolOverridden().format({
+                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.symbolOverridden().format({
                             name: memberName,
                             className: baseClass.details.name,
                         }) + diagAddendum.getString(), (_d = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _d !== void 0 ? _d : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
-                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
+                            diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
                         }
                     }
                     else if (overriddenTDEntry && overrideTDEntry) {
@@ -4592,14 +4536,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         if (!isRequiredCompatible) {
                             const message = overrideTDEntry.isRequired
-                                ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
-                                : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
-                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (_e = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _e !== void 0 ? _e : lastDecl.node);
+                                ? localize_1.LocMessage.typedDictFieldRequiredRedefinition
+                                : localize_1.LocMessage.typedDictFieldNotRequiredRedefinition;
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (_e = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _e !== void 0 ? _e : lastDecl.node);
                         }
                         // Make sure that the derived class isn't marking a previously writable
                         // entry as read-only.
                         if (!overriddenTDEntry.isReadOnly && overrideTDEntry.isReadOnly) {
-                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
                                 name: memberName,
                             }), (_f = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _f !== void 0 ? _f : lastDecl.node);
                         }
@@ -4608,12 +4552,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const isBaseVarFinal = this._evaluator.isFinalVariable(baseClassAndSymbol.symbol);
                     const overrideFinalVarDecl = decls.find((d) => this._evaluator.isFinalVariableDeclaration(d));
                     if (!isBaseVarFinal && overrideFinalVarDecl) {
-                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.variableFinalOverride().format({
+                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.variableFinalOverride().format({
                             name: memberName,
                             className: baseClass.details.name,
                         }), (_g = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _g !== void 0 ? _g : lastDecl.node);
                         if (diag) {
-                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
+                            diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
                         }
                     }
                     // Verify that a class variable isn't overriding an instance
@@ -4635,15 +4579,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     if (isBaseClassVar !== isClassVar) {
                         const unformattedMessage = overrideSymbol.isClassVar()
-                            ? localize_1.Localizer.Diagnostic.classVarOverridesInstanceVar()
-                            : localize_1.Localizer.Diagnostic.instanceVarOverridesClassVar();
-                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
+                            ? localize_1.LocMessage.classVarOverridesInstanceVar()
+                            : localize_1.LocMessage.instanceVarOverridesClassVar();
+                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
                             name: memberName,
                             className: baseClass.details.name,
                         }), (_h = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _h !== void 0 ? _h : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
-                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
+                            diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
                         }
                     }
                 }
@@ -4671,7 +4615,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (node.parameters.length === 0 ||
                 !node.parameters[0].name ||
                 !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs', 'metacls'].some((name) => node.parameters[0].name.value === name)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.newClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.newClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
             }
             if (classType) {
                 this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
@@ -4685,7 +4629,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (node.parameters.length > 0 && node.parameters[0].name) {
                 const paramName = node.parameters[0].name.value;
                 if (paramName === 'self' || paramName === 'cls') {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.staticClsSelfParam(), node.parameters[0].name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.staticClsSelfParam(), node.parameters[0].name);
                 }
             }
         }
@@ -4699,7 +4643,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // cases in the stdlib pyi files.
             if (paramName !== 'cls') {
                 if (!this._fileInfo.isStubFile || (!paramName.startsWith('_') && paramName !== 'metacls')) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.classMethodClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.classMethodClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
                 }
             }
             if (classType) {
@@ -4743,7 +4687,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // a parameter that cannot be positional.
                     const isPrivateName = SymbolNameUtils.isPrivateOrProtectedName(paramName);
                     if (!isLegalMetaclassName && !isPrivateName) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.instanceMethodSelfParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.instanceMethodSelfParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
                     }
                 }
             }
@@ -4800,7 +4744,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         callNodeWalker.walk(node.suite);
         // If we didn't find a call to at least one base class, report the problem.
         if (!foundCallOfMember) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingSuperCall, diagnosticRules_1.DiagnosticRule.reportMissingSuperCall, localize_1.Localizer.Diagnostic.missingSuperCall().format({
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingSuperCall, localize_1.LocMessage.missingSuperCall().format({
                 methodName: methodType.details.name,
             }), node.name);
         }
@@ -4856,7 +4800,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!this._evaluator.assignType(paramType, expectedType, /* diag */ undefined, typeVarContext)) {
             // We exempt Never from this check because it has a legitimate use in this case.
             if (!(0, types_1.isNever)(paramType)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.clsSelfParamTypeMismatch().format({
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.clsSelfParamTypeMismatch().format({
                     name: paramInfo.name,
                     classType: this._evaluator.printType(expectedType),
                 }), paramInfo.typeAnnotation);
@@ -4897,7 +4841,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         if ((0, types_1.isNever)(declaredReturnType)) {
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnContainsYield(), node);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnContainsYield(), node);
             return;
         }
         const generatorTypeArgs = [yieldType, sendType !== null && sendType !== void 0 ? sendType : types_1.UnknownType.create(), types_1.UnknownType.create()];
@@ -4905,9 +4849,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
             const errorMessage = enclosingFunctionNode.isAsync
-                ? localize_1.Localizer.Diagnostic.generatorAsyncReturnType()
-                : localize_1.Localizer.Diagnostic.generatorSyncReturnType();
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, errorMessage.format({ yieldType: this._evaluator.printType(yieldType) }) +
+                ? localize_1.LocMessage.generatorAsyncReturnType()
+                : localize_1.LocMessage.generatorSyncReturnType();
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, 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);
         }
     }
@@ -4965,7 +4909,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         return (0, typeUtils_1.derivesFromClassRecursive)(thisExceptType, previousExceptType, /* ignoreUnknown */ true);
                     });
                     if (subtype) {
-                        diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.unreachableExcept().format({
+                        diagAddendum.addMessage(localize_1.LocAddendum.unreachableExcept().format({
                             exceptionType: this._evaluator.printType((0, typeUtils_1.convertToInstance)(thisExceptType)),
                             parentType: this._evaluator.printType((0, typeUtils_1.convertToInstance)(subtype)),
                         }));
@@ -4974,7 +4918,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 });
                 // Were all of the exception types overridden?
                 if (typesOfThisExcept.length > 0 && typesOfThisExcept.length === overriddenExceptionCount) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unreachableExcept() + diagAddendum.getString(), except.typeExpression);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unreachableExcept() + diagAddendum.getString(), except.typeExpression);
                     this._evaluator.addUnreachableCode(except, except.exceptSuite);
                 }
             }
@@ -4992,7 +4936,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (!importFromAs.alias) {
                         const prevImport = symbolMap.get(importFromAs.name.value);
                         if (prevImport) {
-                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDuplicateImport, diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.Localizer.Diagnostic.duplicateImport().format({ importName: importFromAs.name.value }), importFromAs.name);
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.LocMessage.duplicateImport().format({ importName: importFromAs.name.value }), importFromAs.name);
                         }
                         else {
                             symbolMap.set(importFromAs.name.value, importFromAs);
@@ -5005,7 +4949,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!importStatement.subnode.alias) {
                     const prevImport = importModuleMap.get(importStatement.moduleName);
                     if (prevImport) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDuplicateImport, diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.Localizer.Diagnostic.duplicateImport().format({ importName: importStatement.moduleName }), importStatement.subnode);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.LocMessage.duplicateImport().format({ importName: importStatement.moduleName }), importStatement.subnode);
                     }
                     else {
                         importModuleMap.set(importStatement.moduleName, importStatement.subnode);
@@ -5026,12 +4970,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     regionStack.pop();
                 }
                 else {
-                    this._addDiagnosticForRegionComment(regionComment, localize_1.Localizer.Diagnostic.unmatchedEndregionComment());
+                    this._addDiagnosticForRegionComment(regionComment, localize_1.LocMessage.unmatchedEndregionComment());
                 }
             }
         });
         regionStack.forEach((regionComment) => {
-            this._addDiagnosticForRegionComment(regionComment, localize_1.Localizer.Diagnostic.unmatchedRegionComment());
+            this._addDiagnosticForRegionComment(regionComment, localize_1.LocMessage.unmatchedRegionComment());
         });
     }
     _addDiagnosticForRegionComment(regionComment, message) {