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

package/dist/analyzer/typeEvaluator.js

@@ -162,7 +162,7 @@ const maxRecursiveTypeAliasRecursionCount = 10;
 // This switch enables a special debug mode that attempts to catch
 // bugs due to inconsistent evaluation flags used when reading types
 // from the type cache.
-const verifyTypeCacheEvaluatorFlags = true;
+const verifyTypeCacheEvaluatorFlags = false;
 // This debugging option prints each expression and its evaluated type.
 const printExpressionTypes = false;
 // The following number is chosen somewhat arbitrarily. We need to cut
@@ -175,6 +175,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     const asymmetricAccessorAssignmentCache = new Set();
     const speculativeTypeTracker = new typeCacheUtils_1.SpeculativeTypeTracker();
     const suppressedNodeStack = [];
+    const assignClassToSelfStack = [];
     let functionRecursionMap = new Set();
     let codeFlowAnalyzerCache = new Map();
     let typeCache = new Map();
@@ -546,6 +547,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         initializedBasicTypes(node);
         let typeResult;
         let expectingInstantiable = (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0;
+        let allowSpeculativeCaching = true;
         switch (node.nodeType) {
             case 38 /* ParseNodeType.Name */: {
                 typeResult = getTypeOfName(node, flags);
@@ -645,11 +647,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             case 4 /* ParseNodeType.AssignmentExpression */: {
                 if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-                    addError(localize_1.Localizer.Diagnostic.walrusNotAllowed(), node);
+                    addError(localize_1.LocMessage.walrusNotAllowed(), node);
                 }
                 typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext);
                 assignTypeToExpression(node.name, typeResult.type, !!typeResult.isIncomplete, node.rightExpression, 
                 /* ignoreEmptyContainers */ true);
+                // Don't allow speculative caching for assignment expressions because
+                // the target name node won't have a corresponding type cached speculatively.
+                allowSpeculativeCaching = false;
                 break;
             }
             case 60 /* ParseNodeType.Yield */: {
@@ -712,7 +717,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
             }
         }
-        writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
+        writeTypeCache(node, typeResult, flags, inferenceContext, allowSpeculativeCaching);
         // If there was an expected type, make sure that the result type is compatible.
         if (inferenceContext &&
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
@@ -757,7 +762,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (isTypeCheckingOnly) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             if (!fileInfo.isStubFile) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeCheckOnly().format({ name }), node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeCheckOnly().format({ name }), node);
             }
         }
     }
@@ -769,7 +774,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (flags & 64 /* EvaluatorFlags.DisallowTypeVarTuple */) {
             if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
-                addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
+                addError(localize_1.LocMessage.typeVarTupleContext(), node);
                 typeResult.type = types_1.UnknownType.create();
             }
         }
@@ -787,7 +792,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfAwaitOperator(node, flags, inferenceContext) {
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-            addError(localize_1.Localizer.Diagnostic.awaitNotAllowed(), node);
+            addError(localize_1.LocMessage.awaitNotAllowed(), node);
             return { type: types_1.UnknownType.create() };
         }
         const effectiveExpectedType = inferenceContext
@@ -851,7 +856,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
         }
         else if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-            addError(localize_1.Localizer.Diagnostic.unpackInAnnotation(), node, node.starToken);
+            addError(localize_1.LocMessage.unpackInAnnotation(), node, node.starToken);
             typeResult = { type: types_1.UnknownType.create() };
         }
         else {
@@ -890,8 +895,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (!typeResult) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.expectedTypeNotString(), node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedTypeNotString(), node);
                 typeResult = { type: types_1.UnknownType.create() };
             }
         }
@@ -1101,7 +1105,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const annotationType = getTypeOfExpression(node, evaluatorFlags).type;
         if ((0, types_1.isModule)(annotationType)) {
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleAsType(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.moduleAsType(), node);
         }
         return (0, typeUtils_1.convertToInstance)(annotationType);
     }
@@ -1330,7 +1334,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfBoundMember(errorNode, objectType, memberName, usage = { method: 'get' }, diag = undefined, flags = 0 /* MemberAccessFlags.Default */, selfType, recursionCount = 0) {
         if (types_1.ClassType.isPartiallyEvaluated(objectType)) {
             if (errorNode) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classDefinitionCycle().format({ name: objectType.details.name }), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classDefinitionCycle().format({ name: objectType.details.name }), errorNode);
             }
             return { type: types_1.UnknownType.create() };
         }
@@ -1368,7 +1372,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!skipObjectTypeLookup) {
             let effectiveFlags = flags;
             if (objectTypeIsInstantiable) {
-                effectiveFlags |= 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */;
+                effectiveFlags |=
+                    16 /* MemberAccessFlags.SkipInstanceMembers */ |
+                        512 /* MemberAccessFlags.SkipAttributeAccessOverride */ |
+                        1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */;
                 effectiveFlags &= ~32 /* MemberAccessFlags.SkipClassMembers */;
             }
             else {
@@ -1520,8 +1527,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let constructorType;
                         // Try to get the `__init__` method first because it typically has more
                         // type information than `__new__`.
-                        const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, callNode, types_1.ClassType.cloneAsInstance(subtype), 
-                        /* skipObjectBase */ false);
+                        const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, callNode, types_1.ClassType.cloneAsInstance(subtype), 0 /* MemberAccessFlags.Default */);
                         if (initMethodResult && !initMethodResult.typeErrors) {
                             if ((0, types_1.isFunction)(initMethodResult.type) || (0, types_1.isOverloadedFunction)(initMethodResult.type)) {
                                 constructorType = initMethodResult.type;
@@ -1537,8 +1543,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // the `object` class or accepts only default parameters(* args, ** kwargs),
                         // see if we can find a better signature from the `__new__` method.
                         if (!constructorType || isObjectInit || isDefaultParams) {
-                            const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype, 
-                            /* skipObjectBase */ false);
+                            const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype, 0 /* MemberAccessFlags.Default */);
                             if (newMethodResult && !newMethodResult.typeErrors && (0, types_1.isFunction)(newMethodResult.type)) {
                                 if ((0, types_1.isFunction)(newMethodResult.type) &&
                                     newMethodResult.type.details.fullName !== 'builtins.object.__new__') {
@@ -1761,8 +1766,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (errorNode) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotAwaitable().format({ type: printType(subtype) }) + (diag === null || diag === void 0 ? void 0 : diag.getString()), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotAwaitable().format({ type: printType(subtype) }) + (diag === null || diag === void 0 ? void 0 : diag.getString()), errorNode);
             }
             return types_1.UnknownType.create();
         });
@@ -1777,7 +1781,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         type = makeTopLevelTypeVarsConcrete(type);
         if ((0, typeUtils_1.isOptionalType)(type)) {
             if (!typeResult.isIncomplete && emitNotIterableError) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalIterable, diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.Localizer.Diagnostic.noneNotIterable(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.LocMessage.noneNotIterable(), errorNode);
             }
             type = (0, typeUtils_1.removeNoneFromUnion)(type);
         }
@@ -1811,7 +1815,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return getItemReturnType;
                         }
                     }
-                    diag.addMessage(localize_1.Localizer.Diagnostic.methodNotDefined().format({ name: iterMethodName }));
+                    diag.addMessage(localize_1.LocMessage.methodNotDefined().format({ name: iterMethodName }));
                 }
                 else {
                     const iterReturnTypeDiag = new diagnostic_1.DiagnosticAddendum();
@@ -1823,7 +1827,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if ((0, types_1.isClassInstance)(subtype)) {
                             let nextReturnType = getTypeOfMagicMethodCall(subtype, nextMethodName, [], errorNode);
                             if (!nextReturnType) {
-                                iterReturnTypeDiag.addMessage(localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
+                                iterReturnTypeDiag.addMessage(localize_1.LocMessage.methodNotDefinedOnType().format({
                                     name: nextMethodName,
                                     type: printType(subtype),
                                 }));
@@ -1846,7 +1850,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         }
                         else {
-                            iterReturnTypeDiag.addMessage(localize_1.Localizer.Diagnostic.methodReturnsNonObject().format({ name: iterMethodName }));
+                            iterReturnTypeDiag.addMessage(localize_1.LocMessage.methodReturnsNonObject().format({ name: iterMethodName }));
                         }
                         return undefined;
                     });
@@ -1857,7 +1861,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (!typeResult.isIncomplete && emitNotIterableError) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIterable().format({ type: printType(subtype) }) + diag.getString(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotIterable().format({ type: printType(subtype) }) + diag.getString(), errorNode);
             }
             isValidIterator = false;
             return undefined;
@@ -1871,7 +1875,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let type = makeTopLevelTypeVarsConcrete(typeResult.type);
         if ((0, typeUtils_1.isOptionalType)(type)) {
             if (!typeResult.isIncomplete && emitNotIterableError) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalIterable, diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.Localizer.Diagnostic.noneNotIterable(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.LocMessage.noneNotIterable(), errorNode);
             }
             type = (0, typeUtils_1.removeNoneFromUnion)(type);
         }
@@ -1886,7 +1890,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (emitNotIterableError) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIterable().format({ type: printType(subtype) }), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotIterable().format({ type: printType(subtype) }), errorNode);
             }
             isValidIterable = false;
             return undefined;
@@ -1984,7 +1988,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 errorRange = { start: 0, length: 0 };
             }
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            addDiagnosticForTextRange(fileInfo, fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.codeTooComplexToAnalyze(), errorRange);
+            addDiagnosticForTextRange(fileInfo, fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), errorRange);
             return true;
         }
         return false;
@@ -2064,22 +2068,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function addInformation(message, node, range) {
         return addDiagnosticWithSuppressionCheck('information', message, node, range);
     }
-    function addWarning(message, node, range) {
-        return addDiagnosticWithSuppressionCheck('warning', message, node, range);
-    }
     function addError(message, node, range) {
         return addDiagnosticWithSuppressionCheck('error', message, node, range);
     }
     function addUnusedCode(node, textRange) {
         if (!isDiagnosticSuppressedForNode(node)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unreachableCode(), textRange);
+            fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unreachableCode(), textRange);
         }
     }
     function addUnreachableCode(node, textRange) {
         if (!isDiagnosticSuppressedForNode(node)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            fileInfo.diagnosticSink.addUnreachableCodeWithTextRange(localize_1.Localizer.Diagnostic.unreachableCode(), textRange);
+            fileInfo.diagnosticSink.addUnreachableCodeWithTextRange(localize_1.LocMessage.unreachableCode(), textRange);
         }
     }
     function addDeprecated(message, node) {
@@ -2099,18 +2100,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return (suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode)) ||
             speculativeTypeTracker.isSpeculative(node, /* ignoreIfDiagnosticsAllowed */ true));
     }
-    function addDiagnostic(diagLevel, rule, message, node, range) {
+    function addDiagnostic(rule, message, node, range) {
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const diagLevel = fileInfo.diagnosticRuleSet[rule];
         if (diagLevel === 'none') {
             return undefined;
         }
-        // Should we suppress this diagnostic because it's within an unannotated function?
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        if (!fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions) {
-            const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
-            // Is the target node within the body of the function? If so, suppress the diagnostic.
-            if (containingFunction &&
-                ParseTreeUtils.isUnannotatedFunction(containingFunction) &&
-                ParseTreeUtils.isNodeContainedWithin(node, containingFunction.suite)) {
+        const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
+        if (containingFunction) {
+            // Should we suppress this diagnostic because it's within an unannotated function?
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            if (!fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions) {
+                // Is the target node within the body of the function? If so, suppress the diagnostic.
+                if (ParseTreeUtils.isUnannotatedFunction(containingFunction) &&
+                    ParseTreeUtils.isNodeContainedWithin(node, containingFunction.suite)) {
+                    return undefined;
+                }
+            }
+            // Should we suppress this diagnostic because it's within a no_type_check function?
+            const containingClassNode = ParseTreeUtils.getEnclosingClass(containingFunction, /* stopAtFunction */ true);
+            const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, containingFunction, !!containingClassNode);
+            if ((functionInfo.flags & 524288 /* FunctionTypeFlags.NoTypeCheck */) !== 0) {
                 return undefined;
             }
         }
@@ -2131,16 +2141,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return diagnostic;
     }
     function addExpectedClassDiagnostic(type, node) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const diag = new diagnostic_1.DiagnosticAddendum();
         if ((0, types_1.isUnion)(type)) {
             (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
                 if (!(0, typeUtils_1.isEffectivelyInstantiable)(subtype)) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeNotClass().format({ type: printType(subtype) }));
+                    diag.addMessage(localize_1.LocAddendum.typeNotClass().format({ type: printType(subtype) }));
                 }
             });
         }
-        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeExpectedClass().format({ type: printType(type) }) + diag.getString(), node);
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeExpectedClass().format({ type: printType(type) }) + diag.getString(), node);
     }
     function assignTypeToNameNode(nameNode, type, isTypeIncomplete, ignoreEmptyContainers, srcExpression, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
         var _a, _b, _c;
@@ -2179,7 +2188,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiagAddendum) {
                     diagAddendum = expectedTypeDiagAddendum;
                 }
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
                     diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
                 // Replace the assigned type with the (unnarrowed) declared type.
                 destType = declaredType;
@@ -2209,11 +2218,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // A constant variable can be assigned only once. If this
                 // isn't the first assignment, generate an error.
                 if (nameNode !== (0, declarationUtils_1.getNameNodeForDeclaration)(declarations[0])) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportConstantRedefinition, diagnosticRules_1.DiagnosticRule.reportConstantRedefinition, localize_1.Localizer.Diagnostic.constantRedefinition().format({ name: nameValue }), nameNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportConstantRedefinition, localize_1.LocMessage.constantRedefinition().format({ name: nameValue }), nameNode);
                 }
             }
             else if (isFinalVariableDeclaration(varDecl) && !allowAssignmentToFinalVar) {
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.finalReassigned().format({ name: nameValue }), nameNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name: nameValue }), nameNode);
             }
         }
         if (!isTypeIncomplete) {
@@ -2252,7 +2261,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 return !ParseTreeUtils.getEnclosingFunction(decl.node);
                             });
                             if (classLevelDecls.length === 0) {
-                                addError(localize_1.Localizer.Diagnostic.assignmentInProtocol(), target.memberName);
+                                addError(localize_1.LocMessage.assignmentInProtocol(), target.memberName);
                             }
                         }
                     }
@@ -2315,7 +2324,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }
                             }
                             if (!isPotentiallyDescriptor) {
-                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.slotsAttributeError().format({ name: memberName }), node.memberName);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.slotsAttributeError().format({ name: memberName }), node.memberName);
                             }
                         }
                     }
@@ -2330,7 +2339,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         srcExprNode &&
                         node.memberName !== typedDecls[0].node) {
                         if (typedDecls[0].isConstant) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportConstantRedefinition, diagnosticRules_1.DiagnosticRule.reportConstantRedefinition, localize_1.Localizer.Diagnostic.constantRedefinition().format({ name: node.memberName.value }), node.memberName);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportConstantRedefinition, localize_1.LocMessage.constantRedefinition().format({ name: node.memberName.value }), node.memberName);
                         }
                     }
                 }
@@ -2412,11 +2421,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const expectedEntryCount = unpackIndex >= 0 ? targetExpressions.length - 1 : targetExpressions.length;
                     const subDiag = diagAddendum.createAddendum();
                     subDiag.addMessage((target.nodeType === 31 /* ParseNodeType.List */
-                        ? localize_1.Localizer.DiagnosticAddendum.listAssignmentMismatch()
-                        : localize_1.Localizer.DiagnosticAddendum.tupleAssignmentMismatch()).format({
+                        ? localize_1.LocAddendum.listAssignmentMismatch()
+                        : localize_1.LocAddendum.tupleAssignmentMismatch()).format({
                         type: printType(subtype),
                     }));
-                    subDiag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.tupleSizeMismatch().format({
+                    subDiag.createAddendum().addMessage(localize_1.LocAddendum.tupleSizeMismatch().format({
                         expected: expectedEntryCount,
                         received: sourceEntryTypes.length,
                     }));
@@ -2432,10 +2441,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (!diagAddendum.isEmpty()) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(target);
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, (target.nodeType === 31 /* ParseNodeType.List */
-                ? localize_1.Localizer.Diagnostic.listAssignmentMismatch()
-                : localize_1.Localizer.Diagnostic.tupleAssignmentMismatch()).format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, (target.nodeType === 31 /* ParseNodeType.List */
+                ? localize_1.LocMessage.listAssignmentMismatch()
+                : localize_1.LocMessage.tupleAssignmentMismatch()).format({
                 type: printType(type),
             }) + diagAddendum.getString(), target);
         }
@@ -2690,10 +2698,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const typeVarTarget = target.nodeType === 54 /* ParseNodeType.TypeAnnotation */ ? target.valueExpression : target;
                     if (typeVarTarget.nodeType !== 38 /* ParseNodeType.Name */ || typeVarTarget.value !== type.details.name) {
                         addError(type.details.isParamSpec
-                            ? localize_1.Localizer.Diagnostic.paramSpecAssignedName().format({
+                            ? localize_1.LocMessage.paramSpecAssignedName().format({
                                 name: types_1.TypeVarType.getReadableName(type),
                             })
-                            : localize_1.Localizer.Diagnostic.typeVarAssignedName().format({
+                            : localize_1.LocMessage.typeVarAssignedName().format({
                                 name: types_1.TypeVarType.getReadableName(type),
                             }), typeVarTarget);
                     }
@@ -2772,7 +2780,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             default: {
-                addError(localize_1.Localizer.Diagnostic.assignmentTargetExpr(), target);
+                addError(localize_1.LocMessage.assignmentTargetExpr(), target);
                 break;
             }
         }
@@ -2792,7 +2800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if ((0, types_1.isInstantiableClass)(concreteSubtype) && concreteSubtype.literalValue === undefined) {
                             if (!(0, typeUtils_1.derivesFromClassRecursive)(concreteSubtype, baseExceptionType, 
                             /* ignoreUnknown */ false)) {
-                                diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                                diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
                                     type: printType(subtype),
                                 }));
                             }
@@ -2804,7 +2812,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     /* inferenceContext */ undefined);
                                 });
                                 if (callResult && callResult.argumentErrors) {
-                                    diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeNotInstantiable().format({
+                                    diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeNotInstantiable().format({
                                         type: printType(subtype),
                                     }));
                                 }
@@ -2813,21 +2821,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         else if ((0, types_1.isClassInstance)(concreteSubtype)) {
                             if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(concreteSubtype), baseExceptionType, 
                             /* ignoreUnknown */ false)) {
-                                diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                                diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
                                     type: printType(subtype),
                                 }));
                             }
                         }
                         else {
-                            diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                            diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
                                 type: printType(subtype),
                             }));
                         }
                     }
                 });
                 if (!diagAddendum.isEmpty()) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.expectedExceptionClass() + diagAddendum.getString(), node.typeExpression);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedExceptionClass() + diagAddendum.getString(), node.typeExpression);
                 }
             }
         }
@@ -2874,8 +2881,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             default: {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.delTargetExpr(), node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.delTargetExpr(), node);
                 break;
             }
         }
@@ -2947,7 +2953,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncomplete = true;
                 }
                 if (effectiveTypeInfo.isRecursiveDefinition && isNodeReachable(node)) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.recursiveDefinition().format({ name }), node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.recursiveDefinition().format({ name }), node);
                 }
                 const isSpecialBuiltIn = !!effectiveType && (0, types_1.isInstantiableClass)(effectiveType) && types_1.ClassType.isSpecialBuiltIn(effectiveType);
                 type = effectiveType;
@@ -3012,7 +3018,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (effectiveTypeInfo.includesIllegalTypeAliasDecl ||
                                 !types_1.TypeBase.isInstantiable(type) ||
                                 (flags & 2 /* EvaluatorFlags.DoNotSpecialize */) !== 0) {
-                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationVariable(), node);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), node);
                                 type = types_1.UnknownType.create();
                             }
                         }
@@ -3025,14 +3031,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type = types_1.AnyType.create();
                 }
                 else {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportUndefinedVariable, diagnosticRules_1.DiagnosticRule.reportUndefinedVariable, localize_1.Localizer.Diagnostic.symbolIsUndefined().format({ name }), node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUndefinedVariable, localize_1.LocMessage.symbolIsUndefined().format({ name }), node);
                     type = types_1.UnknownType.create();
                 }
             }
         }
         if ((0, types_1.isParamSpec)(type)) {
             if (flags & 32 /* EvaluatorFlags.DisallowParamSpec */) {
-                addError(localize_1.Localizer.Diagnostic.paramSpecContext(), node);
+                addError(localize_1.LocMessage.paramSpecContext(), node);
                 type = types_1.UnknownType.create();
             }
         }
@@ -3043,7 +3049,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0) {
             if ((flags & 1024 /* EvaluatorFlags.AllowGenericClassType */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericNotAllowed(), node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericNotAllowed(), node);
                 }
             }
         }
@@ -3053,35 +3059,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, isIncomplete };
     }
     // If the type is a TypeVar and we're not expecting a type, convert
-    // a TypeVar or TypeVarTuple into a runtime type. We don't currently
-    // do this for ParamSpec (although we arguably should) because it's
-    // problematic for handling P.args and P.kwargs.
+    // a TypeVar, TypeVarTuple or ParamSpec into a runtime type.
     function convertTypeVarToRuntimeInstance(node, type, flags) {
         var _a;
-        if (node.nodeType === 38 /* ParseNodeType.Name */ &&
-            (0, types_1.isTypeVar)(type) &&
-            node.value === type.details.name &&
-            !type.isVariadicInUnion &&
-            (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) === 0) {
-            if ((flags & 33554432 /* EvaluatorFlags.SkipConvertParamSpecToRuntimeObject */) !== 0 && type.details.isParamSpec) {
-                return type;
-            }
-            // Handle the special case of a PEP 604 union. These can appear within
-            // an implied type alias where we are not expecting a type.
-            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* ParseNodeType.BinaryOperation */ &&
-                node.parent.operator === 6 /* OperatorType.BitwiseOr */;
-            if (!isPep604Union) {
-                // A TypeVar in contexts where we're not expecting a type is
-                // simply a runtime object.
-                if (type.details.runtimeClass) {
-                    type = types_1.ClassType.cloneAsInstance(type.details.runtimeClass);
-                }
-                else {
-                    type = types_1.UnknownType.create();
-                }
-            }
+        if (!type.specialForm || type.typeAliasInfo) {
+            return type;
         }
-        return type;
+        if (!(0, types_1.isTypeVar)(type) || type.isVariadicInUnion || (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0) {
+            return type;
+        }
+        if ((flags & 33554432 /* EvaluatorFlags.SkipConvertParamSpecToRuntimeObject */) !== 0 && type.details.isParamSpec) {
+            return types_1.TypeBase.cloneAsSpecialForm(type, undefined);
+        }
+        // Handle the special case of a PEP 604 union. These can appear within
+        // an implied type alias where we are not expecting a type.
+        const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* ParseNodeType.BinaryOperation */ && node.parent.operator === 6 /* OperatorType.BitwiseOr */;
+        if (isPep604Union) {
+            return types_1.TypeBase.cloneAsSpecialForm(type, undefined);
+        }
+        return types_1.ClassType.cloneAsInstance(type.specialForm);
     }
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (a function, lambda, or comprehension).
@@ -3165,7 +3161,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         !typeVarScopeNode.typeParameters.parameters.some((t) => t.name === node)) {
                         return type;
                     }
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarUsedByOuterScope().format({ name: type.details.name }), node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: type.details.name }), node);
                 }
             }
             else if ((flags & 8192 /* EvaluatorFlags.AssociateTypeVarsWithCurrentScope */) !== 0) {
@@ -3181,8 +3177,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 const outerFunctionScope = ParseTreeUtils.getEnclosingClassOrFunction(enclosingScope);
                                 if ((outerFunctionScope === null || outerFunctionScope === void 0 ? void 0 : outerFunctionScope.nodeType) === 28 /* ParseNodeType.Function */) {
                                     if (scopedTypeVarInfo.isRescoped) {
-                                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet
-                                            .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecScopedToReturnType().format({
+                                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecScopedToReturnType().format({
                                             name: type.details.name,
                                         }), node);
                                     }
@@ -3191,7 +3186,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     }
                                 }
                                 else if (!scopedTypeVarInfo.type.scopeId) {
-                                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotUsedByOuterScope().format({
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecNotUsedByOuterScope().format({
                                         name: type.details.name,
                                     }), node);
                                 }
@@ -3202,7 +3197,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // type variables can't be used in this context.
                             if (enclosingScope.typeParameters &&
                                 !enclosingScope.typeParameters.parameters.some((param) => param.name.value === type.details.name)) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeParameterNotDeclared().format({
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeParameterNotDeclared().format({
                                     name: type.details.name,
                                     container: enclosingScope.name.value,
                                 }), node);
@@ -3216,7 +3211,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarUsedByOuterScope().format({ name: type.details.name }), node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: type.details.name }), node);
                     }
                 }
             }
@@ -3226,15 +3221,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     let message;
                     if (scopedTypeVarInfo.isRescoped) {
                         message = (0, types_1.isParamSpec)(type)
-                            ? localize_1.Localizer.Diagnostic.paramSpecScopedToReturnType()
-                            : localize_1.Localizer.Diagnostic.typeVarScopedToReturnType();
+                            ? localize_1.LocMessage.paramSpecScopedToReturnType()
+                            : localize_1.LocMessage.typeVarScopedToReturnType();
                     }
                     else {
                         message = (0, types_1.isParamSpec)(type)
-                            ? localize_1.Localizer.Diagnostic.paramSpecNotUsedByOuterScope()
-                            : localize_1.Localizer.Diagnostic.typeVarNotUsedByOuterScope();
+                            ? localize_1.LocMessage.paramSpecNotUsedByOuterScope()
+                            : localize_1.LocMessage.typeVarNotUsedByOuterScope();
                     }
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name: type.details.name }), node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name: type.details.name }), node);
                 }
             }
         }
@@ -3259,7 +3254,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (flags & 512 /* EvaluatorFlags.AllowMissingTypeArgs */) === 0) {
                 if (!type.typeAliasInfo && (0, typeUtils_1.requiresTypeArguments)(type)) {
                     if (!type.typeArguments || !type.isTypeArgumentExplicit) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForClass().format({
                             name: type.aliasName || type.details.name,
                         }), node);
                     }
@@ -3298,7 +3293,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeVarContext.setTypeVarType(param, defaultType);
             });
             if (reportMissingTypeArguments) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForAlias().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForAlias().format({
                     name: type.typeAliasInfo.name,
                 }), node);
             }
@@ -3380,7 +3375,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     leftType.details.recursiveTypeAliasName) {
                     // Type alias statements cannot be used with old-style type variables.
                     if (typeAliasNode && !type.details.isTypeParamSyntax) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeParameterNotDeclared().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeParameterNotDeclared().format({
                             name: type.details.name,
                             container: typeAliasNode.name.value,
                         }), node);
@@ -3499,7 +3494,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
-        var _a, _b;
+        var _a;
         let baseType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(baseTypeResult.type);
         const memberName = node.memberName.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
@@ -3540,8 +3535,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const expectedCategory = isArgs ? 1 /* ParameterCategory.ArgsList */ : 2 /* ParameterCategory.KwargsDict */;
                         if (!paramNode || paramNode.category !== expectedCategory) {
                             const errorMessage = isArgs
-                                ? localize_1.Localizer.Diagnostic.paramSpecArgsUsage()
-                                : localize_1.Localizer.Diagnostic.paramSpecKwargsUsage();
+                                ? localize_1.LocMessage.paramSpecArgsUsage()
+                                : localize_1.LocMessage.paramSpecKwargsUsage();
                             addError(errorMessage, node);
                             type = types_1.UnknownType.create(isIncomplete);
                             break;
@@ -3550,7 +3545,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         break;
                     }
                     if (!isIncomplete) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecUnknownMember().format({ name: memberName }), node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecUnknownMember().format({ name: memberName }), node);
                     }
                     type = types_1.UnknownType.create(isIncomplete);
                     break;
@@ -3558,7 +3553,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // It's illegal to reference a member from a type variable.
                 if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
                     if (!isIncomplete) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNoMember().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarNoMember().format({
                             type: printType(baseType),
                             name: memberName,
                         }), node.leftExpression);
@@ -3581,8 +3576,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }, usage, 0 /* EvaluatorFlags.None */);
             }
             case 6 /* TypeCategory.Class */: {
-                const typeResult = (_a = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete)) !== null && _a !== void 0 ? _a : getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
-                /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
+                let typeResult;
+                if (usage.method === 'get') {
+                    typeResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
+                }
+                if (!typeResult) {
+                    typeResult = getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
+                    /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
+                }
                 if (typeResult) {
                     type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
                     /* skipSelfCondition */ true);
@@ -3618,12 +3619,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         type = types_1.UnknownType.create(/* isIncomplete */ true);
                     }
                     if (symbol.isPrivateMember()) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportPrivateUsage, diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.Localizer.Diagnostic.privateUsedOutsideOfModule().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.LocMessage.privateUsedOutsideOfModule().format({
                             name: memberName,
                         }), node.memberName);
                     }
                     if (symbol.isPrivatePyTypedImport()) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportPrivateImportUsage, diagnosticRules_1.DiagnosticRule.reportPrivateImportUsage, localize_1.Localizer.Diagnostic.privateImportFromPyTypedModule().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateImportUsage, localize_1.LocMessage.privateImportFromPyTypedModule().format({
                             name: memberName,
                             module: baseType.moduleName,
                         }), node.memberName);
@@ -3654,7 +3655,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (!type) {
                         if (!isIncomplete) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleUnknownMember().format({
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, localize_1.LocMessage.moduleUnknownMember().format({
                                 memberName,
                                 moduleName: baseType.moduleName,
                             }), node.memberName);
@@ -3681,7 +3682,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return type;
                         }
                         if (!isIncomplete) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportOptionalMemberAccess, diagnosticRules_1.DiagnosticRule.reportOptionalMemberAccess, localize_1.Localizer.Diagnostic.noneUnknownMember().format({ name: memberName }), node.memberName);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalMemberAccess, localize_1.LocMessage.noneUnknownMember().format({ name: memberName }), node.memberName);
                         }
                         return undefined;
                     }
@@ -3725,12 +3726,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, types_1.isOverloadedFunction)(baseType) ||
                 ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, 'function'));
             if (!baseTypeResult.isIncomplete) {
-                let diagMessage = localize_1.Localizer.Diagnostic.memberAccess();
+                let diagMessage = localize_1.LocMessage.memberAccess();
                 if (usage.method === 'set') {
-                    diagMessage = localize_1.Localizer.Diagnostic.memberSet();
+                    diagMessage = localize_1.LocMessage.memberSet();
                 }
                 else if (usage.method === 'del') {
-                    diagMessage = localize_1.Localizer.Diagnostic.memberDelete();
+                    diagMessage = localize_1.LocMessage.memberDelete();
                 }
                 // If there is an expected type diagnostic addendum (used for assignments),
                 // use that rather than the local diagnostic addendum because it will be
@@ -3738,10 +3739,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (usage.setExpectedTypeDiag) {
                     diag = usage.setExpectedTypeDiag;
                 }
-                const [ruleSet, rule] = isFunctionRule
-                    ? [fileInfo.diagnosticRuleSet.reportFunctionMemberAccess, diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess]
-                    : [fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues];
-                addDiagnostic(ruleSet, rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node.memberName);
+                const rule = isFunctionRule
+                    ? diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess
+                    : diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue;
+                addDiagnostic(rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : node.memberName);
             }
             // If this is member access on a function, use "Any" so if the
             // reportFunctionMemberAccess rule is disabled, we don't trigger
@@ -3782,13 +3783,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             // Report that the member could not be accessed.
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberUnknown().format({ name: memberName }));
             return undefined;
         }
         let type;
         let isTypeIncomplete = false;
         if (memberInfo.symbol.isInitVar()) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsInitVar().format({ name: memberName }));
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberIsInitVar().format({ name: memberName }));
             return undefined;
         }
         if (usage.method !== 'get' && errorNode) {
@@ -3811,7 +3812,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // clear the flag that causes an error to be generated.
                     if (usage.method === 'set' && memberInfo.symbol.isClassVar() && isAccessedThroughObject) {
                         const selfClass = (selfType !== null && selfType !== void 0 ? selfType : memberName === '__new__') ? undefined : classType;
-                        const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
+                        const typeResult = getTypeOfMemberInternal(errorNode, memberInfo, selfClass, flags);
                         if (typeResult) {
                             if ((0, typeUtils_1.isDescriptorInstance)(typeResult.type, /* requireSetter */ true)) {
                                 type = typeResult.type;
@@ -3837,7 +3838,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     selfClass = classType;
                 }
             }
-            const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
+            const typeResult = getTypeOfMemberInternal(errorNode, memberInfo, selfClass, flags);
             type = (_c = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
             if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
                 isTypeIncomplete = true;
@@ -3847,7 +3848,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isClass)(memberInfo.classType) && types_1.ClassType.isTypedDictClass(memberInfo.classType)) {
             const typedDecls = memberInfo.symbol.getTypedDeclarations();
             if (typedDecls.length > 0 && typedDecls[0].type === 1 /* DeclarationType.Variable */) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberUnknown().format({ name: memberName }));
                 return undefined;
             }
         }
@@ -3911,7 +3912,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!isDescriptorApplied &&
                 (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.isClassVar()) &&
                 (flags & 128 /* MemberAccessFlags.DisallowClassVarWrites */) !== 0) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberSetClassVar().format({ name: memberName }));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberSetClassVar().format({ name: memberName }));
                 isDescriptorError = true;
             }
             // Check for an attempt to overwrite a final member variable.
@@ -3923,7 +3924,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // being assigned within an __init__ method, it's allowed.
                 const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(errorNode);
                 if (!enclosingFunctionNode || enclosingFunctionNode.name.value !== '__init__') {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.finalReassigned().format({ name: memberName }));
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocMessage.finalReassigned().format({ name: memberName }));
                     isDescriptorError = true;
                 }
             }
@@ -3932,7 +3933,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.isInstanceMember) &&
                 (0, types_1.isClass)(memberInfo.classType) &&
                 types_1.ClassType.isReadOnlyInstanceVariables(memberInfo.classType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.readOnlyAttribute().format({ name: memberName }));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.readOnlyAttribute().format({ name: memberName }));
                 isDescriptorError = true;
             }
             return resultType;
@@ -3941,7 +3942,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Verify that the assigned type is compatible.
             if (!assignType(type, usage.setType.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
                 if (!usage.setType.isIncomplete) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberAssignment().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberAssignment().format({
                         type: printType(usage.setType.type),
                         name: memberName,
                         classType: printObjectTypeForClass(classType),
@@ -3952,7 +3953,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
                 types_1.ClassType.isFrozenDataClass(memberInfo.classType) &&
                 isAccessedThroughObject) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.dataClassFrozen().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.dataClassFrozen().format({
                     name: printType(types_1.ClassType.cloneAsInstance(memberInfo.classType)),
                 }));
                 isDescriptorError = true;
@@ -3992,8 +3993,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (types_1.ClassType.isPropertyClass(concreteMemberType)) {
                 if (usage.method !== 'get') {
                     const message = usage.method === 'set'
-                        ? localize_1.Localizer.DiagnosticAddendum.propertyMissingSetter()
-                        : localize_1.Localizer.DiagnosticAddendum.propertyMissingDeleter();
+                        ? localize_1.LocAddendum.propertyMissingSetter()
+                        : localize_1.LocAddendum.propertyMissingDeleter();
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(message.format({ name: memberName }));
                     return { type: types_1.AnyType.create(), typeErrors: true };
                 }
@@ -4022,7 +4023,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // interpreted as a read-only attribute rather than a protocol, so accessing
             // it directly from the class has an ambiguous meaning.
             if ((flags & 16 /* MemberAccessFlags.SkipInstanceMembers */) !== 0 && types_1.ClassType.isProtocolClass(classType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyAccessFromProtocolClass());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.propertyAccessFromProtocolClass());
                 return { type: memberType, typeErrors: true };
             }
             // Infer return types before specializing. Otherwise a generic inferred
@@ -4062,7 +4063,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (!methodType) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.descriptorAccessBindingFailed().format({
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.descriptorAccessBindingFailed().format({
                 name: accessMethodName,
                 className: printType((0, typeUtils_1.convertToInstance)(methodClassType)),
             }));
@@ -4150,17 +4151,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 methodType.details.parameters.length >= 2 &&
                 !usage.setType.isIncomplete) {
                 const setterType = types_1.FunctionType.getEffectiveParameterType(methodType, 1);
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeIncompatible().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeIncompatible().format({
                     destType: printType(setterType),
                     sourceType: printType(usage.setType.type),
                 }));
             }
             else if ((0, types_1.isOverloadedFunction)(methodType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.noOverload().format({ name: accessMethodName }));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocMessage.noOverload().format({ name: accessMethodName }));
             }
         }
         else {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.descriptorAccessCallFailed().format({
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.descriptorAccessCallFailed().format({
                 name: accessMethodName,
                 className: printType((0, typeUtils_1.convertToInstance)(methodClassType)),
             }));
@@ -4180,7 +4181,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ? concreteType
                 : types_1.OverloadedFunctionType.getImplementation(concreteType);
             if (impl && types_1.FunctionType.isFinal(impl) && memberInfo && (0, types_1.isClass)(memberInfo.classType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocMessage.finalMethodOverride().format({
                     name: memberName,
                     className: memberInfo.classType.details.name,
                 }));
@@ -4335,7 +4336,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // runtime exception.
         if (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) {
             if (node.baseExpression.nodeType === 48 /* ParseNodeType.StringList */) {
-                addError(localize_1.Localizer.Diagnostic.stringNotSubscriptable(), node.baseExpression);
+                addError(localize_1.LocMessage.stringNotSubscriptable(), node.baseExpression);
             }
         }
         // Check for builtin classes that will generate runtime exceptions if subscripted.
@@ -4359,7 +4360,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (minPythonVersion !== undefined &&
                         fileInfo.executionEnvironment.pythonVersion < minPythonVersion &&
                         !fileInfo.isStubFile) {
-                        addError(localize_1.Localizer.Diagnostic.classNotRuntimeSubscriptable().format({
+                        addError(localize_1.LocMessage.classNotRuntimeSubscriptable().format({
                             name: baseTypeResult.type.aliasName || baseTypeResult.type.details.name,
                         }), node.baseExpression);
                     }
@@ -4498,7 +4499,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // If the variadic type variable is not unpacked, report an error.
     function validateVariadicTypeVarIsUnpacked(type, node) {
         if (!type.isVariadicUnpacked) {
-            addError(localize_1.Localizer.Diagnostic.unpackedTypeVarTupleExpected().format({
+            addError(localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
                 name1: type.details.name,
                 name2: type.details.name,
             }), node);
@@ -4545,14 +4546,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             minTypeArgCount = firstDefaultParamIndex;
         }
         if (typeArgs.length > typeParameters.length) {
-            addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+            addError(localize_1.LocMessage.typeArgsTooMany().format({
                 name: printType(baseType),
                 expected: typeParameters.length,
                 received: typeArgs.length,
             }), typeArgs[typeParameters.length].node);
         }
         else if (typeArgs.length < minTypeArgCount) {
-            addError(localize_1.Localizer.Diagnostic.typeArgsTooFew().format({
+            addError(localize_1.LocMessage.typeArgsTooFew().format({
                 name: printType(baseType),
                 expected: typeParameters.length,
                 received: typeArgs.length,
@@ -4623,12 +4624,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.typeArgListExpected(), typeArgs[index].node);
+                    addError(localize_1.LocMessage.typeArgListExpected(), typeArgs[index].node);
                 }
             }
             else {
                 if (index < typeArgs.length && typeArgs[index].typeList) {
-                    addError(localize_1.Localizer.Diagnostic.typeArgListNotAllowed(), typeArgs[index].node);
+                    addError(localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[index].node);
                 }
                 let typeArgType;
                 if (index < typeArgs.length) {
@@ -4646,7 +4647,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const usageVariance = usageVariances[index];
                         if (!(0, typeUtils_1.isVarianceOfTypeArgumentCompatible)(typeArgType, usageVariance)) {
                             const messageDiag = diag.createAddendum();
-                            messageDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatchForTypeAlias().format({
+                            messageDiag.addMessage(localize_1.LocAddendum.varianceMismatchForTypeAlias().format({
                                 typeVarName: printType(typeArgType),
                                 typeAliasParam: printType(typeParameters[index]),
                             }));
@@ -4656,7 +4657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if ((0, types_1.isUnpacked)(typeArgType) && !(0, types_1.isVariadicTypeVar)(param)) {
                     const messageDiag = diag.createAddendum();
-                    messageDiag.addMessage(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument());
+                    messageDiag.addMessage(localize_1.LocMessage.unpackedArgInTypeArgument());
                     messageDiag.addTextRange(typeArgs[index].node);
                     typeArgType = types_1.UnknownType.create();
                 }
@@ -4664,7 +4665,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (!diag.isEmpty()) {
-            addError(localize_1.Localizer.Diagnostic.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node);
+            addError(localize_1.LocMessage.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node);
         }
         const primarySignatureContext = typeVarContext.getPrimarySignature();
         const aliasTypeArgs = [];
@@ -4714,7 +4715,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) {
                 if ((0, types_1.isTypeVar)(unexpandedSubtype)) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNotSubscriptable().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarNotSubscriptable().format({
                         type: printType(unexpandedSubtype),
                     }), node.baseExpression);
                     // Evaluate the index expressions as though they are type arguments for error-reporting.
@@ -4731,7 +4732,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const itemMethodType = getBoundMagicMethod(concreteSubtype, getIndexAccessMagicMethodName(usage));
                     if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
                         // If the class doesn't derive from Generic, a type argument should not be allowed.
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                             name: printType(types_1.ClassType.cloneAsInstance(concreteSubtype)),
                         }), node);
                     }
@@ -4742,10 +4743,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Setting the value of an indexed class will always result
                 // in an exception.
                 if (usage.method === 'set') {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericClassAssigned(), node.baseExpression);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericClassAssigned(), node.baseExpression);
                 }
                 else if (usage.method === 'del') {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericClassDeleted(), node.baseExpression);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericClassDeleted(), node.baseExpression);
                 }
                 if (types_1.ClassType.isSpecialBuiltIn(concreteSubtype, 'Literal')) {
                     // Special-case Literal types.
@@ -4758,7 +4759,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return typeArgs[0].type;
                     }
                     else {
-                        addError(localize_1.Localizer.Diagnostic.typeArgsMismatchOne().format({ received: typeArgs.length }), node.baseExpression);
+                        addError(localize_1.LocMessage.typeArgsMismatchOne().format({ received: typeArgs.length }), node.baseExpression);
                         return types_1.UnknownType.create();
                     }
                 }
@@ -4799,7 +4800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return concreteSubtype;
                 }
                 if (concreteSubtype.typeArguments) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classAlreadySpecialized().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.classAlreadySpecialized().format({
                         type: printType((0, typeUtils_1.convertToInstance)(concreteSubtype), { expandTypeAlias: true }),
                     }), node.baseExpression);
                     return concreteSubtype;
@@ -4818,7 +4819,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if ((0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
                 if (!isIncomplete) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalSubscript, diagnosticRules_1.DiagnosticRule.reportOptionalSubscript, localize_1.Localizer.Diagnostic.noneNotSubscriptable(), node.baseExpression);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalSubscript, localize_1.LocMessage.noneNotSubscriptable(), node.baseExpression);
                 }
                 return types_1.UnknownType.create();
             }
@@ -4836,8 +4837,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return types_1.UnknownType.create();
             }
             if (!isIncomplete) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSubscriptable().format({ type: printType(concreteSubtype) }), node.baseExpression);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.typeNotSubscriptable().format({ type: printType(concreteSubtype) }), node.baseExpression);
             }
             return types_1.UnknownType.create();
         });
@@ -4968,8 +4968,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const magicMethodName = getIndexAccessMagicMethodName(usage);
         const itemMethodType = getBoundMagicMethod(baseType, magicMethodName, selfType);
         if (!itemMethodType) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.methodNotDefinedOnType().format({
                 name: magicMethodName,
                 type: printType(baseType),
             }), node.baseExpression);
@@ -5257,13 +5256,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
                             }
                             else {
-                                addError(localize_1.Localizer.Diagnostic.unpackNotAllowed(), arg.valueExpression);
+                                addError(localize_1.LocMessage.unpackNotAllowed(), arg.valueExpression);
                             }
                         }
                     }
                 }
                 if (arg.name) {
-                    addError(localize_1.Localizer.Diagnostic.keywordArgInTypeArgument(), arg.valueExpression);
+                    addError(localize_1.LocMessage.keywordArgInTypeArgument(), arg.valueExpression);
                 }
                 typeArgs.push(typeResult);
             });
@@ -5305,12 +5304,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
             if (node.nodeType === 15 /* ParseNodeType.Dictionary */) {
-                addError(localize_1.Localizer.Diagnostic.dictInAnnotation(), node);
+                addError(localize_1.LocMessage.dictInAnnotation(), node);
             }
             if ((flags & 131072 /* EvaluatorFlags.DisallowClassVar */) !== 0) {
                 // "ClassVar" is not allowed as a type argument.
                 if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ClassVar')) {
-                    addError(localize_1.Localizer.Diagnostic.classVarNotAllowed(), node);
+                    addError(localize_1.LocMessage.classVarNotAllowed(), node);
                 }
             }
         }
@@ -5324,8 +5323,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // to support Tuple[()], which is the documented way to annotate
             // a zero-length tuple.
             const diag = new diagnostic_1.DiagnosticAddendum();
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useTupleInstead());
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.tupleInAnnotation() + diag.getString(), node);
+            diag.addMessage(localize_1.LocAddendum.useTupleInstead());
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.tupleInAnnotation() + diag.getString(), node);
             return { type: types_1.UnknownType.create() };
         }
         if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0 &&
@@ -5493,8 +5492,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
             node.leftExpression.value === 'type') {
             const diag = new diagnostic_1.DiagnosticAddendum();
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useTypeInstead());
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeCallNotAllowed() + diag.getString(), node);
+            diag.addMessage(localize_1.LocAddendum.useTypeInstead());
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeCallNotAllowed() + diag.getString(), node);
         }
         // Handle immediate calls of lambdas specially.
         if (node.leftExpression.nodeType === 30 /* ParseNodeType.Lambda */) {
@@ -5546,7 +5545,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeResult.type = getTypeOfRevealLocals(node);
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.revealLocalsArgs(), node);
+                    addError(localize_1.LocMessage.revealLocalsArgs(), node);
                 }
             }
             else {
@@ -5594,7 +5593,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationCall(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationCall(), node);
             typeResult = { type: types_1.UnknownType.create() };
         }
         return typeResult;
@@ -5652,7 +5651,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             node.arguments[0].name !== undefined ||
             node.arguments[0].argumentCategory !== 0 /* ArgumentCategory.Simple */ ||
             node.arguments[1].name !== undefined) {
-            addError(localize_1.Localizer.Diagnostic.assertTypeArgs(), node);
+            addError(localize_1.LocMessage.assertTypeArgs(), node);
             return { type: types_1.UnknownType.create() };
         }
         const arg0TypeResult = getTypeOfExpression(node.arguments[0].valueExpression, 
@@ -5663,7 +5662,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgumentExpectingType(node.arguments[1]).type);
         if (!(0, types_1.isTypeSame)(assertedType, arg0TypeResult.type, { treatAnySameAsUnknown: true, ignorePseudoGeneric: true })) {
             const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.assertTypeTypeMismatch().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
                 expected: srcDestTypes.destType,
                 received: srcDestTypes.sourceType,
             }), node.arguments[0].valueExpression);
@@ -5692,7 +5691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!(0, types_1.isClassInstance)(expectedTextType) ||
                     !types_1.ClassType.isBuiltIn(expectedTextType, 'str') ||
                     typeof expectedTextType.literalValue !== 'string') {
-                    addError(localize_1.Localizer.Diagnostic.revealTypeExpectedTextArg(), arg.valueExpression);
+                    addError(localize_1.LocMessage.revealTypeExpectedTextArg(), arg.valueExpression);
                 }
                 else {
                     expectedText = expectedTextType.literalValue;
@@ -5704,7 +5703,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (!arg0Value) {
-            addError(localize_1.Localizer.Diagnostic.revealTypeArgs(), node);
+            addError(localize_1.LocMessage.revealTypeArgs(), node);
             return { type: types_1.UnknownType.create() };
         }
         const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, inferenceContext);
@@ -5713,7 +5712,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeString = printType(type, { expandTypeAlias: true });
         if (expectedText !== undefined) {
             if (expectedText !== typeString) {
-                addError(localize_1.Localizer.Diagnostic.revealTypeExpectedTextMismatch().format({
+                addError(localize_1.LocMessage.revealTypeExpectedTextMismatch().format({
                     expected: expectedText,
                     received: typeString,
                 }), expectedTextNode !== null && expectedTextNode !== void 0 ? expectedTextNode : arg0Value);
@@ -5722,13 +5721,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (expectedRevealType) {
             if (!(0, types_1.isTypeSame)(expectedRevealType, type, { ignorePseudoGeneric: true })) {
                 const expectedRevealTypeText = printType(expectedRevealType);
-                addError(localize_1.Localizer.Diagnostic.revealTypeExpectedTypeMismatch().format({
+                addError(localize_1.LocMessage.revealTypeExpectedTypeMismatch().format({
                     expected: expectedRevealTypeText,
                     received: typeString,
                 }), expectedRevealTypeNode !== null && expectedRevealTypeNode !== void 0 ? expectedRevealTypeNode : arg0Value);
             }
         }
-        addInformation(localize_1.Localizer.DiagnosticAddendum.typeOfSymbol().format({ name: exprString, type: typeString }), node.arguments[0]);
+        addInformation(localize_1.LocAddendum.typeOfSymbol().format({ name: exprString, type: typeString }), node.arguments[0]);
         return { type, isIncomplete: typeResult.isIncomplete };
     }
     function getTypeOfRevealLocals(node) {
@@ -5748,7 +5747,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             scope.symbolTable.forEach((symbol, name) => {
                 if (!symbol.isIgnoredForProtocolMatch()) {
                     const typeOfSymbol = getEffectiveTypeOfSymbol(symbol);
-                    infoMessages.push(localize_1.Localizer.DiagnosticAddendum.typeOfSymbol().format({
+                    infoMessages.push(localize_1.LocAddendum.typeOfSymbol().format({
                         name,
                         type: printType(typeOfSymbol, { expandTypeAlias: true }),
                     }));
@@ -5759,14 +5758,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addInformation(infoMessages.join('\n'), node);
         }
         else {
-            addInformation(localize_1.Localizer.Diagnostic.revealLocalsNone(), node);
+            addInformation(localize_1.LocMessage.revealLocalsNone(), node);
         }
         return getNoneType();
     }
     function getTypeOfSuperCall(node) {
         var _a;
         if (node.arguments.length > 2) {
-            addError(localize_1.Localizer.Diagnostic.superCallArgCount(), node.arguments[2]);
+            addError(localize_1.LocMessage.superCallArgCount(), node.arguments[2]);
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunctionEvaluationScope(node);
         const enclosingClass = enclosingFunction ? ParseTreeUtils.getEnclosingClass(enclosingFunction) : undefined;
@@ -5778,7 +5777,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             targetClassType = getTypeOfExpression(node.arguments[0].valueExpression).type;
             const concreteTargetClassType = makeTopLevelTypeVarsConcrete(targetClassType);
             if (!(0, types_1.isAnyOrUnknown)(concreteTargetClassType) && !(0, types_1.isInstantiableClass)(concreteTargetClassType)) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.superCallFirstArg().format({ type: printType(targetClassType) }), node.arguments[0].valueExpression);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.superCallFirstArg().format({ type: printType(targetClassType) }), node.arguments[0].valueExpression);
             }
         }
         else {
@@ -5790,13 +5789,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
                     /* isInClass */ true);
                     if (((functionInfo === null || functionInfo === void 0 ? void 0 : functionInfo.flags) & 4 /* FunctionTypeFlags.StaticMethod */) !== 0) {
-                        addError(localize_1.Localizer.Diagnostic.superCallZeroArgFormStaticMethod(), node.leftExpression);
+                        addError(localize_1.LocMessage.superCallZeroArgFormStaticMethod(), node.leftExpression);
                         targetClassType = types_1.UnknownType.create();
                     }
                 }
             }
             else {
-                addError(localize_1.Localizer.Diagnostic.superCallZeroArgForm(), node.leftExpression);
+                addError(localize_1.LocMessage.superCallZeroArgForm(), node.leftExpression);
                 targetClassType = types_1.UnknownType.create();
             }
         }
@@ -5830,8 +5829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 reportError = true;
             }
             if (reportError) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.superCallSecondArg().format({ type: printType(targetClassType) }), node.arguments[1].valueExpression);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.superCallSecondArg().format({ type: printType(targetClassType) }), node.arguments[1].valueExpression);
                 return { type: types_1.UnknownType.create() };
             }
         }
@@ -6265,8 +6263,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return typeString;
                 });
-                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
+                diagAddendum.addMessage(localize_1.LocAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
             }
             return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall: [] };
         }
@@ -6286,10 +6284,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // was possible and emit a diagnostic that provides the most likely.
             if (emitNoOverloadFoundError) {
                 const functionName = bestMatch.overload.details.name || '<anonymous function>';
-                const diagnostic = addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }), errorNode);
+                const diagnostic = addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.noOverload().format({ name: functionName }), errorNode);
                 const overrideDecl = bestMatch.overload.details.declaration;
                 if (diagnostic && overrideDecl) {
-                    diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.uri, overrideDecl.range);
+                    diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.uri, overrideDecl.range);
                 }
             }
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
@@ -6417,7 +6415,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Special forms are not callable.
         if (callTypeResult.type.specialForm) {
             const exprNode = errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode;
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                 type: printType(callTypeResult.type, { expandTypeAlias: true }),
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
@@ -6481,7 +6479,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             case 6 /* TypeCategory.Class */: {
                 if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalCall, diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.Localizer.Diagnostic.noneNotCallable(), errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.LocMessage.noneNotCallable(), errorNode);
                     return { argumentErrors: true };
                 }
                 if (types_1.TypeBase.isInstantiable(expandedCallType)) {
@@ -6497,7 +6495,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return validateCallArguments(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
             }
             case 7 /* TypeCategory.Module */: {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleNotCallable(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
                 return { argumentErrors: true };
             }
         }
@@ -6506,7 +6504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a;
         if (types_1.TypeBase.isInstantiable(expandedCallType)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.callableNotInstantiable().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.callableNotInstantiable().format({
                 type: printType(expandedCallType),
             }), errorNode);
             return { returnType: undefined, argumentErrors: true };
@@ -6519,7 +6517,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // The stdlib collections/__init__.pyi stub file defines namedtuple
         // as a function rather than a class, so we need to check for it here.
         if (expandedCallType.details.builtInName === 'namedtuple') {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUntypedNamedTuple, diagnosticRules_1.DiagnosticRule.reportUntypedNamedTuple, localize_1.Localizer.Diagnostic.namedTupleNoTypes(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUntypedNamedTuple, localize_1.LocMessage.namedTupleNoTypes(), errorNode);
             const result = {
                 returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ false),
             };
@@ -6563,40 +6561,79 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             specializedInitSelfType: functionResult.specializedInitSelfType,
         };
     }
-    function isMethodUnimplementedAbstract(functionType) {
+    // Determines whether a symbol is abstract. In an ABC class, this means a function
+    // is specifically decorated with @abstractmethod. In a protocol class, the rules
+    // are more complicated and depend on whether the method is defined in a stub file.
+    function getAbstractSymbolInfo(classType, symbolName) {
+        const isProtocolClass = types_1.ClassType.isProtocolClass(classType);
+        const symbol = classType.details.fields.get(symbolName);
+        if (!symbol) {
+            return undefined;
+        }
+        // Ignore instance variables. Also, ignore named tuple members, which are
+        // modeled in pyright as instance variables, but their runtime implementation
+        // uses a descriptor object.
+        if (!symbol.isClassMember() && !symbol.isNamedTupleMemberMember()) {
+            return undefined;
+        }
+        const lastDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+        if (!lastDecl) {
+            return undefined;
+        }
+        // Handle protocol variables specially.
+        if (isProtocolClass && lastDecl.type === 1 /* DeclarationType.Variable */) {
+            // If none of the declarations involve assignments, assume it's
+            // not implemented in the protocol.
+            const allDecls = symbol.getDeclarations();
+            if (!allDecls.some((decl) => decl.type === 1 /* DeclarationType.Variable */ && !!decl.inferredTypeSource)) {
+                return { symbol, symbolName, classType, hasImplementation: false };
+            }
+        }
+        if (lastDecl.type !== 5 /* DeclarationType.Function */) {
+            return undefined;
+        }
         let isAbstract = false;
-        // If the function is part of a protocol, it's automatically considered abstract
-        // unless it's located in a stub, in which case it must be explicitly marked as
-        // abstract.
-        if (types_1.FunctionType.isAbstractMethod(functionType)) {
+        const lastFunctionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, lastDecl.node, /* isInClass */ true);
+        if ((lastFunctionInfo.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0) {
             isAbstract = true;
         }
-        else if (functionType.details.methodClass &&
-            types_1.ClassType.isProtocolClass(functionType.details.methodClass) &&
-            functionType.details.declaration &&
-            !AnalyzerNodeInfo.getFileInfo(functionType.details.declaration.node).isStubFile) {
-            isAbstract = true;
+        const isStubFile = AnalyzerNodeInfo.getFileInfo(lastDecl.node).isStubFile;
+        // In an overloaded method, the first overload can also be marked abstract.
+        // In stub files, there is no implementation, so this is the only way to mark
+        // an overloaded method as abstract.
+        const firstDecl = symbol.getDeclarations()[0];
+        let firstFunctionInfo;
+        if (firstDecl !== lastDecl && firstDecl.type === 5 /* DeclarationType.Function */) {
+            firstFunctionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, firstDecl.node, /* isInClass */ true);
+            if ((firstFunctionInfo.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0) {
+                isAbstract = true;
+            }
+            // If there's no implementation, assume it's unimplemented.
+            if (isProtocolClass && (lastFunctionInfo.flags & 256 /* FunctionTypeFlags.Overloaded */) !== 0) {
+                // If this is a protocol class method defined in a stub file and
+                // it's not marked abstract, assume it's not abstract and implemented.
+                if (isProtocolClass && !isAbstract && isStubFile) {
+                    return undefined;
+                }
+                return { symbol, symbolName, classType, hasImplementation: false };
+            }
         }
-        if (!isAbstract) {
-            return false;
+        // In a non-protocol class, if the method isn't explicitly marked abstract,
+        // then it's not abstract.
+        if (!isProtocolClass && !isAbstract) {
+            return undefined;
         }
-        // Determine if the method is unimplemented by looking at whether its
-        // body contains a "trivial" implementation.
-        let implementation = functionType;
-        // If this is an overloaded method, consider the implementation.
-        if (functionType.overloaded) {
-            implementation = types_1.OverloadedFunctionType.getImplementation(functionType.overloaded);
-            // If there is no implementation and it's in a stub file, assume it's not abstract.
-            if (!implementation) {
-                return (functionType.details.declaration !== undefined &&
-                    !AnalyzerNodeInfo.getFileInfo(functionType.details.declaration.node).isStubFile);
+        const hasImplementation = !ParseTreeUtils.isSuiteEmpty(lastDecl.node.suite) && !methodAlwaysRaisesNotImplemented(lastDecl);
+        // If this is a protocol class, the method isn't explicitly marked
+        // as abstract, and there is an implementation, then it's a default
+        // implementation, and it's not considered abstract. If it's in a stub
+        // file, assume it's implemented in this case.
+        if (isProtocolClass && !isAbstract) {
+            if (hasImplementation || isStubFile) {
+                return undefined;
             }
         }
-        if (!implementation.details.declaration) {
-            return false;
-        }
-        const decl = implementation.details.declaration;
-        return ParseTreeUtils.isSuiteEmpty(decl.node.suite) || methodAlwaysRaisesNotImplemented(decl);
+        return { symbol, symbolName, classType, hasImplementation };
     }
     function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
@@ -6634,7 +6671,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         if (expandedCallType.literalValue !== undefined) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.literalNotCallable(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.literalNotCallable(), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
         if (types_1.ClassType.isBuiltIn(expandedCallType)) {
@@ -6642,7 +6679,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Handle a call to a metaclass explicitly.
             if ((0, typeUtils_1.isInstantiableMetaclass)(expandedCallType)) {
                 if (expandedCallType.typeArguments && expandedCallType.isTypeArgumentExplicit) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                         type: printType(expandedCallType),
                     }), errorNode);
                     return { returnType: types_1.UnknownType.create(), argumentErrors: true };
@@ -6702,8 +6739,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const result = {
                     returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ true),
                 };
-                const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 
-                /* skipObjectBase */ false);
+                const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 0 /* MemberAccessFlags.Default */);
                 if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
                     validateOverloadedFunctionArguments(errorNode, argList, { type: initTypeResult.type }, 
                     /* typeVarContext */ undefined, skipUnknownArgCheck, 
@@ -6715,15 +6751,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return { returnType: createNewType(errorNode, argList) };
             }
             if (types_1.ClassType.isSpecialFormClass(expandedCallType)) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIntantiable().format({ type: className }), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeNotIntantiable().format({ type: className }), errorNode);
                 return { returnType: types_1.UnknownType.create(), argumentErrors: true };
             }
-            if ((0, types_1.isClass)(unexpandedCallType) && (0, enums_1.isKnownEnumType)(className)) {
-                return {
-                    returnType: (_b = (0, enums_1.createEnumType)(evaluatorInterface, errorNode, expandedCallType, argList)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create(),
-                };
-            }
             if (className === 'TypedDict') {
                 return { returnType: (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedCallType, argList) };
             }
@@ -6731,36 +6761,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return { returnType: (0, enums_1.getEnumAutoValueType)(evaluatorInterface, errorNode) };
             }
         }
+        // Is it a call to an Enum class factory?
+        if ((0, types_1.isClass)(expandedCallType) &&
+            expandedCallType.details.effectiveMetaclass &&
+            (0, types_1.isClass)(expandedCallType.details.effectiveMetaclass) &&
+            (0, enums_1.isEnumMetaclass)(expandedCallType.details.effectiveMetaclass) &&
+            !(0, enums_1.isEnumClassWithMembers)(evaluatorInterface, expandedCallType)) {
+            return {
+                returnType: (_b = (0, enums_1.createEnumType)(evaluatorInterface, errorNode, expandedCallType, argList)) !== null && _b !== void 0 ? _b : (0, typeUtils_1.convertToInstance)(unexpandedCallType),
+            };
+        }
         if (types_1.ClassType.supportsAbstractMethods(expandedCallType)) {
-            const abstractMethods = getAbstractMethods(expandedCallType);
-            if (abstractMethods.length > 0 && !expandedCallType.includeSubclasses && !(0, types_1.isTypeVar)(unexpandedCallType)) {
+            const abstractSymbols = getAbstractSymbols(expandedCallType);
+            if (abstractSymbols.length > 0 && !expandedCallType.includeSubclasses && !(0, types_1.isTypeVar)(unexpandedCallType)) {
                 // If the class is abstract, it can't be instantiated.
                 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,
                             }));
                         }
                     }
                 });
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.instantiateAbstract().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAbstractUsage, localize_1.LocMessage.instantiateAbstract().format({
                     type: expandedCallType.details.name,
                 }) + diagAddendum.getString(), errorNode);
             }
         }
         if (types_1.ClassType.isProtocolClass(expandedCallType) && !expandedCallType.includeSubclasses) {
             // If the class is a protocol, it can't be instantiated.
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.instantiateProtocol().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAbstractUsage, localize_1.LocMessage.instantiateProtocol().format({
                 type: expandedCallType.details.name,
             }), errorNode);
         }
@@ -6808,7 +6848,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* selfType */ undefined, recursionCount);
         const callMethodType = callMethodResult === null || callMethodResult === void 0 ? void 0 : callMethodResult.type;
         if (!callMethodType) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                 type: printType(expandedCallType),
             }), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
@@ -6838,7 +6878,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
                 ignorePseudoGeneric: true,
             })) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUnnecessaryCast, diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.Localizer.Diagnostic.unnecessaryCast().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.LocMessage.unnecessaryCast().format({
                     type: printType(castFromType),
                 }), errorNode);
             }
@@ -7009,8 +7049,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argIndex < positionalOnlyLimitIndex && argList[argIndex].name) {
                 const nameNode = argList[argIndex].name;
                 if (nameNode) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(nameNode);
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argPositional(), nameNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.argPositional(), nameNode);
                     reportedArgError = true;
                 }
             }
@@ -7044,9 +7083,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (tooManyPositionals) {
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                                ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                                : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
+                                ? localize_1.LocMessage.argPositionalExpectedOne()
+                                : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
                                 }), (_b = argList[argIndex].valueExpression) !== null && _b !== void 0 ? _b : errorNode);
                         }
@@ -7077,9 +7116,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argTypeResult.type.paramSpecAccess === 'args' &&
                         paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                                ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                                : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
+                                ? localize_1.LocMessage.argPositionalExpectedOne()
+                                : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
                                 }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
                         }
@@ -7144,7 +7183,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // parameter unless the argument is a variadic arg as well.
                 if (isParamVariadic && !isArgCompatibleWithVariadic) {
                     if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
                     }
                     reportedArgError = true;
                 }
@@ -7202,9 +7241,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (remainingArgCount < remainingParamCount) {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                                 // Have we run out of arguments and still have parameters left to fill?
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, remainingArgCount === 1
-                                    ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
-                                    : localize_1.Localizer.Diagnostic.argMorePositionalExpectedCount().format({
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, remainingArgCount === 1
+                                    ? localize_1.LocMessage.argMorePositionalExpectedOne()
+                                    : localize_1.LocMessage.argMorePositionalExpectedCount().format({
                                         expected: remainingArgCount,
                                     }), argList[argIndex].valueExpression || errorNode);
                             }
@@ -7284,9 +7323,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (argsRemainingCount > 0) {
                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, argsRemainingCount === 1
-                        ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
-                        : localize_1.Localizer.Diagnostic.argMorePositionalExpectedCount().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, argsRemainingCount === 1
+                        ? localize_1.LocMessage.argMorePositionalExpectedOne()
+                        : localize_1.LocMessage.argMorePositionalExpectedCount().format({
                             expected: argsRemainingCount,
                         }), argList.length > positionalArgCount
                         ? argList[positionalArgCount].valueExpression || errorNode
@@ -7314,7 +7353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const paramEntry = paramMap.get(name);
                             if (paramEntry && !paramEntry.isPositionalOnly) {
                                 if (paramEntry.argsReceived > 0) {
-                                    diag.addMessage(localize_1.Localizer.Diagnostic.paramAlreadyAssigned().format({ name }));
+                                    diag.addMessage(localize_1.LocMessage.paramAlreadyAssigned().format({ name }));
                                 }
                                 else {
                                     paramEntry.argsReceived++;
@@ -7360,13 +7399,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 // getParameterListDetails because it was associated with an unpacked TypedDict.
                                 // In this case, we can skip the error.
                                 if (!paramDetails.hasUnpackedTypedDict) {
-                                    diag.addMessage(localize_1.Localizer.Diagnostic.paramNameMissing().format({ name }));
+                                    diag.addMessage(localize_1.LocMessage.paramNameMissing().format({ name }));
                                 }
                             }
                         });
                         if (!diag.isEmpty()) {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
                             }
                             reportedArgError = true;
                         }
@@ -7427,8 +7466,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                             if (!isValidMappingType) {
                                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet
-                                        .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
                                 }
                                 reportedArgError = true;
                             }
@@ -7449,8 +7487,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (paramEntry && !paramEntry.isPositionalOnly) {
                             if (paramEntry.argsReceived > 0) {
                                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(paramName).diagnosticRuleSet
-                                        .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
                                 }
                                 reportedArgError = true;
                             }
@@ -7494,7 +7531,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         else {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(paramName).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: paramName.value }), paramName);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramNameMissing().format({ name: paramName.value }), paramName);
                             }
                             reportedArgError = true;
                         }
@@ -7505,9 +7542,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         else {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                                    ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                                    : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
+                                    ? localize_1.LocMessage.argPositionalExpectedOne()
+                                    : localize_1.LocMessage.argPositionalExpectedCount().format({
                                         expected: positionParamLimitIndex,
                                     }), argList[argIndex].valueExpression || errorNode);
                             }
@@ -7582,9 +7619,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!isDiagnosticSuppressedForNode(errorNode)) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
-                                ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
-                                : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, unassignedParams.length === 1
+                                ? localize_1.LocMessage.argMissingForParam().format({ name: missingParamNames })
+                                : localize_1.LocMessage.argMissingForParams().format({ names: missingParamNames }), errorNode);
                         }
                     }
                     reportedArgError = true;
@@ -7652,8 +7689,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
                                 !argParam.mapsToVarArgList) {
                                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet
-                                        .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
                                 }
                                 reportedArgError = true;
                             }
@@ -7828,10 +7864,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let anyOrUnknownArgument;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         // Check for an attempt to invoke an unimplemented abstract method.
-        if (type.boundToType && !type.boundToType.includeSubclasses && isMethodUnimplementedAbstract(type)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
-                method: type.details.name,
-            }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
+        if (type.boundToType && !type.boundToType.includeSubclasses && type.details.methodClass) {
+            const abstractSymbolInfo = getAbstractSymbolInfo(type.details.methodClass, type.details.name);
+            if (abstractSymbolInfo && !abstractSymbolInfo.hasImplementation) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAbstractUsage, localize_1.LocMessage.abstractMethodInvocation().format({
+                    method: type.details.name,
+                }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
+            }
         }
         if (type.boundTypeVarScopeId) {
             // If the function was bound to a class or object and was a constructor, a
@@ -7982,7 +8021,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else if (type.details.paramSpec) {
             if (!sawParamSpecArgs || !sawParamSpecKwargs) {
                 if (!isTypeIncomplete) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecArgsMissing().format({ type: printType(type.details.paramSpec) }), errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsMissing().format({ type: printType(type.details.paramSpec) }), errorNode);
                 }
                 argumentErrors = true;
                 argumentMatchScore += 1;
@@ -8252,7 +8291,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argumentErrors = true;
             }
             if (argumentErrors) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecArgsMissing().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsMissing().format({
                     type: printType(functionType.details.paramSpec),
                 }), argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : errorNode);
             }
@@ -8317,8 +8356,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     ? 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
                         8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
                         32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */
-                    : 2 /* EvaluatorFlags.DoNotSpecialize */;
+                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
+                        16 /* EvaluatorFlags.DisallowFinal */
+                    : 2 /* EvaluatorFlags.DoNotSpecialize */ | 16 /* EvaluatorFlags.DisallowFinal */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
                 // If the type includes multiple instances of a generic function
@@ -8445,16 +8485,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Mismatching parameter types are common in untyped code; don't bother spending time
             // printing types if the diagnostic is disabled.
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
-            if (fileInfo.diagnosticRuleSet.reportGeneralTypeIssues !== 'none' &&
+            if (fileInfo.diagnosticRuleSet.reportArgumentType !== 'none' &&
                 !isDiagnosticSuppressedForNode(argParam.errorNode) &&
                 !isTypeIncomplete) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
                 const argTypeText = printType(argType);
                 const paramTypeText = printType(argParam.paramType);
                 let message;
                 if (argParam.paramName && !argParam.isParamNameSynthesized) {
                     if (functionName) {
-                        message = localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
+                        message = localize_1.LocMessage.argAssignmentParamFunction().format({
                             argType: argTypeText,
                             paramType: paramTypeText,
                             functionName,
@@ -8462,7 +8501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         });
                     }
                     else {
-                        message = localize_1.Localizer.Diagnostic.argAssignmentParam().format({
+                        message = localize_1.LocMessage.argAssignmentParam().format({
                             argType: argTypeText,
                             paramType: paramTypeText,
                             paramName: argParam.paramName,
@@ -8471,14 +8510,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else {
                     if (functionName) {
-                        message = localize_1.Localizer.Diagnostic.argAssignmentFunction().format({
+                        message = localize_1.LocMessage.argAssignmentFunction().format({
                             argType: argTypeText,
                             paramType: paramTypeText,
                             functionName,
                         });
                     }
                     else {
-                        message = localize_1.Localizer.Diagnostic.argAssignment().format({
+                        message = localize_1.LocMessage.argAssignment().format({
                             argType: argTypeText,
                             paramType: paramTypeText,
                         });
@@ -8490,7 +8529,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiag) {
                     diag = expectedTypeDiag;
                 }
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), argParam.errorNode, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : argParam.errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, message + diag.getString(), argParam.errorNode, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : argParam.errorNode);
             }
             return { isCompatible: false, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
         }
@@ -8501,11 +8540,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 if (argParam.paramName) {
                     diagAddendum.addMessage((functionName
-                        ? localize_1.Localizer.DiagnosticAddendum.argParamFunction().format({
+                        ? localize_1.LocAddendum.argParamFunction().format({
                             paramName: argParam.paramName,
                             functionName,
                         })
-                        : localize_1.Localizer.DiagnosticAddendum.argParam().format({ paramName: argParam.paramName })) +
+                        : localize_1.LocAddendum.argParam().format({ paramName: argParam.paramName })) +
                         diagAddendum.getString());
                 }
                 return diagAddendum;
@@ -8517,7 +8556,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 !isTypeIncomplete) {
                 if ((0, types_1.isUnknown)(simplifiedType)) {
                     const diagAddendum = getDiagAddendum();
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportUnknownArgumentType, diagnosticRules_1.DiagnosticRule.reportUnknownArgumentType, localize_1.Localizer.Diagnostic.argTypeUnknown() + diagAddendum.getString(), argParam.errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownArgumentType, localize_1.LocMessage.argTypeUnknown() + diagAddendum.getString(), argParam.errorNode);
                 }
                 else if ((0, typeUtils_1.isPartlyUnknown)(simplifiedType)) {
                     // If the parameter type is also partially unknown, don't report
@@ -8525,10 +8564,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // arose due to bidirectional type matching.
                     if (!(0, typeUtils_1.isPartlyUnknown)(argParam.paramType)) {
                         const diagAddendum = getDiagAddendum();
-                        diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentType().format({
+                        diagAddendum.addMessage(localize_1.LocAddendum.argumentType().format({
                             type: printType(simplifiedType, { expandTypeAlias: true }),
                         }));
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportUnknownArgumentType, diagnosticRules_1.DiagnosticRule.reportUnknownArgumentType, localize_1.Localizer.Diagnostic.argTypePartiallyUnknown() + diagAddendum.getString(), argParam.errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownArgumentType, localize_1.LocMessage.argTypePartiallyUnknown() + diagAddendum.getString(), argParam.errorNode);
                     }
                 }
             }
@@ -8541,7 +8580,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let firstConstraintArg;
         let defaultValueNode;
         if (argList.length === 0) {
-            addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), errorNode);
+            addError(localize_1.LocMessage.typeVarFirstArg(), errorNode);
             return undefined;
         }
         const firstArg = argList[0];
@@ -8549,9 +8588,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeVarName = firstArg.valueExpression.strings.map((s) => s.value).join('');
         }
         else {
-            addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), firstArg.valueExpression || errorNode);
+            addError(localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false, classType);
+        const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false), types_1.ClassType.cloneAsInstance(classType));
         // Parse the remaining parameters.
         const paramNameMap = new Map();
         for (let i = 1; i < argList.length; i++) {
@@ -8559,18 +8598,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const paramName = paramNameNode ? paramNameNode.value : undefined;
             if (paramName) {
                 if (paramNameMap.get(paramName)) {
-                    addError(localize_1.Localizer.Diagnostic.duplicateParam().format({ name: paramName }), argList[i].valueExpression || errorNode);
+                    addError(localize_1.LocMessage.duplicateParam().format({ name: paramName }), argList[i].valueExpression || errorNode);
                 }
                 if (paramName === 'bound') {
                     if (typeVar.details.constraints.length > 0) {
-                        addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
+                        addError(localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                     }
                     else {
                         const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : getTypeOfExpressionExpectingType(argList[i].valueExpression, {
                             disallowProtocolAndTypedDict: true,
                         }).type;
                         if ((0, typeUtils_1.requiresSpecialization)(argType, { ignorePseudoGeneric: true, ignoreImplicitTypeArgs: true })) {
-                            addError(localize_1.Localizer.Diagnostic.typeVarBoundGeneric(), argList[i].valueExpression || errorNode);
+                            addError(localize_1.LocMessage.typeVarBoundGeneric(), argList[i].valueExpression || errorNode);
                         }
                         typeVar.details.boundType = (0, typeUtils_1.convertToInstance)(argType);
                     }
@@ -8579,7 +8618,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
                         if (typeVar.details.declaredVariance === 4 /* Variance.Contravariant */ ||
                             typeVar.details.declaredVariance === 0 /* Variance.Auto */) {
-                            addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
+                            addError(localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
                             typeVar.details.declaredVariance = 3 /* Variance.Covariant */;
@@ -8590,7 +8629,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
                         if (typeVar.details.declaredVariance === 3 /* Variance.Covariant */ ||
                             typeVar.details.declaredVariance === 0 /* Variance.Auto */) {
-                            addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
+                            addError(localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
                             typeVar.details.declaredVariance = 4 /* Variance.Contravariant */;
@@ -8601,7 +8640,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
                         if (typeVar.details.declaredVariance === 3 /* Variance.Covariant */ ||
                             typeVar.details.declaredVariance === 4 /* Variance.Contravariant */) {
-                            addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
+                            addError(localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
                             typeVar.details.declaredVariance = 0 /* Variance.Auto */;
@@ -8618,22 +8657,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!fileInfo.isStubFile &&
                         fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
                         classType.details.moduleName !== 'typing_extensions') {
-                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), defaultValueNode);
+                        addError(localize_1.LocMessage.typeVarDefaultIllegal(), defaultValueNode);
                     }
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_e = argList[i].node) === null || _e === void 0 ? void 0 : _e.name) || argList[i].valueExpression || errorNode);
+                    addError(localize_1.LocMessage.typeVarUnknownParam().format({ name: paramName }), ((_e = argList[i].node) === null || _e === void 0 ? void 0 : _e.name) || argList[i].valueExpression || errorNode);
                 }
                 paramNameMap.set(paramName, paramName);
             }
             else {
                 if (typeVar.details.boundType) {
-                    addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
+                    addError(localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
                     const argType = (_g = (_f = argList[i].typeResult) === null || _f === void 0 ? void 0 : _f.type) !== null && _g !== void 0 ? _g : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
                     if ((0, typeUtils_1.requiresSpecialization)(argType, { ignorePseudoGeneric: true })) {
-                        addError(localize_1.Localizer.Diagnostic.typeVarConstraintGeneric(), argList[i].valueExpression || errorNode);
+                        addError(localize_1.LocMessage.typeVarConstraintGeneric(), argList[i].valueExpression || errorNode);
                     }
                     types_1.TypeVarType.addConstraint(typeVar, (0, typeUtils_1.convertToInstance)(argType));
                     if (firstConstraintArg === undefined) {
@@ -8643,7 +8682,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (typeVar.details.constraints.length === 1 && firstConstraintArg) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarSingleConstraint(), firstConstraintArg.valueExpression || errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarSingleConstraint(), firstConstraintArg.valueExpression || errorNode);
         }
         // If a default is provided, make sure it is compatible with the bound
         // or constraint.
@@ -8654,12 +8693,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }));
             if (typeVar.details.boundType) {
                 if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultBoundMismatch(), defaultValueNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultBoundMismatch(), defaultValueNode);
                 }
             }
             else if (typeVar.details.constraints.length > 0) {
                 if (!typeVar.details.constraints.some((constraint) => (0, types_1.isTypeSame)(constraint, concreteDefaultType))) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultConstraintMismatch(), defaultValueNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultConstraintMismatch(), defaultValueNode);
                 }
             }
         }
@@ -8669,7 +8708,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a, _b;
         let typeVarName = '';
         if (argList.length === 0) {
-            addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), errorNode);
+            addError(localize_1.LocMessage.typeVarFirstArg(), errorNode);
             return undefined;
         }
         const firstArg = argList[0];
@@ -8677,9 +8716,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeVarName = firstArg.valueExpression.strings.map((s) => s.value).join('');
         }
         else {
-            addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), firstArg.valueExpression || errorNode);
+            addError(localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false, classType);
+        const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false), types_1.ClassType.cloneAsInstance(classType));
         typeVar.details.isVariadic = true;
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
@@ -8695,15 +8734,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!fileInfo.isStubFile &&
                         fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
                         classType.details.moduleName !== 'typing_extensions') {
-                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), expr);
+                        addError(localize_1.LocMessage.typeVarDefaultIllegal(), expr);
                     }
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
+                    addError(localize_1.LocMessage.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
                 }
             }
             else {
-                addError(localize_1.Localizer.Diagnostic.typeVarTupleConstraints(), argList[i].valueExpression || errorNode);
+                addError(localize_1.LocMessage.typeVarTupleConstraints(), argList[i].valueExpression || errorNode);
             }
         }
         return typeVar;
@@ -8716,14 +8755,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const isUnpackedTuple = (0, types_1.isClass)(argType) && (0, typeUtils_1.isTupleClass)(argType) && argType.isUnpacked;
         const isUnpackedTypeVarTuple = (0, types_1.isUnpackedVariadicTypeVar)(argType);
         if (!isUnpackedTuple && !isUnpackedTypeVarTuple) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarTupleDefaultNotUnpacked(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarTupleDefaultNotUnpacked(), node);
             return undefined;
         }
         return (0, typeUtils_1.convertToInstance)(argType);
     }
     function createParamSpecType(errorNode, classType, argList) {
         if (argList.length === 0) {
-            addError(localize_1.Localizer.Diagnostic.paramSpecFirstArg(), errorNode);
+            addError(localize_1.LocMessage.paramSpecFirstArg(), errorNode);
             return undefined;
         }
         const firstArg = argList[0];
@@ -8732,9 +8771,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             paramSpecName = firstArg.valueExpression.strings.map((s) => s.value).join('');
         }
         else {
-            addError(localize_1.Localizer.Diagnostic.paramSpecFirstArg(), firstArg.valueExpression || errorNode);
+            addError(localize_1.LocMessage.paramSpecFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const paramSpec = types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true, classType);
+        const paramSpec = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true), types_1.ClassType.cloneAsInstance(classType));
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
             const paramNameNode = argList[i].name;
@@ -8749,15 +8788,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!fileInfo.isStubFile &&
                         fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
                         classType.details.moduleName !== 'typing_extensions') {
-                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), expr);
+                        addError(localize_1.LocMessage.typeVarDefaultIllegal(), expr);
                     }
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.paramSpecUnknownParam().format({ name: paramName }), paramNameNode || argList[i].valueExpression || errorNode);
+                    addError(localize_1.LocMessage.paramSpecUnknownParam().format({ name: paramName }), paramNameNode || argList[i].valueExpression || errorNode);
                 }
             }
             else {
-                addError(localize_1.Localizer.Diagnostic.paramSpecUnknownArg(), argList[i].valueExpression || errorNode);
+                addError(localize_1.LocMessage.paramSpecUnknownArg(), argList[i].valueExpression || errorNode);
                 break;
             }
         }
@@ -8806,7 +8845,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return functionType;
             }
         }
-        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecDefaultNotTuple(), node);
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecDefaultNotTuple(), node);
         return undefined;
     }
     // Handles a call to TypeAliasType(). This special form allows a caller to programmatically
@@ -8820,7 +8859,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (errorNode.parent.nodeType !== 3 /* ParseNodeType.Assignment */ ||
             errorNode.parent.rightExpression !== errorNode ||
             errorNode.parent.leftExpression.nodeType !== 38 /* ParseNodeType.Name */) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasTypeMustBeAssigned(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeMustBeAssigned(), errorNode);
             return undefined;
         }
         const nameNode = errorNode.parent.leftExpression;
@@ -8828,11 +8867,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48 /* ParseNodeType.StringList */) {
             const typeAliasName = firstArg.valueExpression.strings.map((s) => s.value).join('');
             if (typeAliasName !== nameNode.value) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasTypeNameMismatch(), firstArg.valueExpression);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeNameMismatch(), firstArg.valueExpression);
             }
         }
         else {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasTypeNameArg(), firstArg.valueExpression || errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeNameArg(), firstArg.valueExpression || errorNode);
             return undefined;
         }
         let valueExpr;
@@ -8866,7 +8905,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let typeParameters;
         if (typeParamsExpr) {
             if (typeParamsExpr.nodeType !== 52 /* ParseNodeType.Tuple */) {
-                addError(localize_1.Localizer.Diagnostic.typeAliasTypeParamInvalid(), typeParamsExpr);
+                addError(localize_1.LocMessage.typeAliasTypeParamInvalid(), typeParamsExpr);
                 return undefined;
             }
             typeParameters = [];
@@ -8887,7 +8926,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
             if (!isTypeParamListValid) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasTypeParamInvalid(), typeParamsExpr);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeParamInvalid(), typeParamsExpr);
                 return undefined;
             }
         }
@@ -8904,7 +8943,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return true;
             }
         }
-        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.expectedBoolLiteral(), node);
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedBoolLiteral(), node);
         return false;
     }
     function getFunctionFullName(functionNode, moduleName, functionName) {
@@ -8928,7 +8967,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         let className = '';
         if (argList.length !== 2) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeParamCount(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.newTypeParamCount(), errorNode);
             return undefined;
         }
         const nameArg = argList[0];
@@ -8938,13 +8977,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             className = nameArg.valueExpression.strings.map((s) => s.value).join('');
         }
         if (!className) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeBadName(), (_a = argList[0].node) !== null && _a !== void 0 ? _a : errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.newTypeBadName(), (_a = argList[0].node) !== null && _a !== void 0 ? _a : errorNode);
             return undefined;
         }
         if (((_b = errorNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */ &&
             errorNode.parent.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
             errorNode.parent.leftExpression.value !== className) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeNameMismatch(), errorNode.parent.leftExpression);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNameMismatch(), errorNode.parent.leftExpression);
             return undefined;
         }
         let baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
@@ -8953,18 +8992,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (objectType && (0, types_1.isClassInstance)(objectType)) {
                 baseClass = types_1.ClassType.cloneAsInstantiable(objectType);
             }
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeAnyOrUnknown(), (_c = argList[1].node) !== null && _c !== void 0 ? _c : errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeAnyOrUnknown(), (_c = argList[1].node) !== null && _c !== void 0 ? _c : errorNode);
             isBaseClassAny = true;
         }
         if (!(0, types_1.isInstantiableClass)(baseClass)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNotAClass(), argList[1].node || errorNode);
             return undefined;
         }
         if (types_1.ClassType.isProtocolClass(baseClass) || types_1.ClassType.isTypedDictClass(baseClass)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeProtocolClass(), argList[1].node || errorNode);
         }
         else if (baseClass.literalValue !== undefined) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeLiteral(), argList[1].node || errorNode);
         }
         let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
         classFlags |= 4096 /* ClassTypeFlags.Final */ | 268435456 /* ClassTypeFlags.NewTypeClass */ | 536870912 /* ClassTypeFlags.ValidTypeAliasClass */;
@@ -9028,7 +9067,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
-            addError(localize_1.Localizer.Diagnostic.methodOrdering(), errorNode);
+            addError(localize_1.LocMessage.methodOrdering(), errorNode);
         }
         return classType;
     }
@@ -9127,8 +9166,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0 &&
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useDictInstead());
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dictInAnnotation() + diag.getString(), node);
+            diag.addMessage(localize_1.LocAddendum.useDictInstead());
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.dictInAnnotation() + diag.getString(), node);
         }
         // If the expected type is a union, analyze for each of the subtypes
         // to find one that matches.
@@ -9413,8 +9452,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else {
-                        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dictUnpackIsNotMapping(), entryNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dictUnpackIsNotMapping(), entryNode);
                     }
                 }
             }
@@ -9451,8 +9489,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             node.nodeType === 31 /* ParseNodeType.List */ &&
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useListInstead());
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.listInAnnotation() + diag.getString(), node);
+            diag.addMessage(localize_1.LocAddendum.useListInstead());
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.listInAnnotation() + diag.getString(), node);
         }
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
@@ -9627,13 +9665,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function verifySetEntryOrDictKeyIsHashable(entry, type, isDictKey) {
         // Verify that the type is hashable.
         if (!isTypeHashable(type)) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(entry);
             const diag = new diagnostic_1.DiagnosticAddendum();
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.unhashableType().format({ type: printType(type) }));
-            const message = isDictKey
-                ? localize_1.Localizer.Diagnostic.unhashableDictKey()
-                : localize_1.Localizer.Diagnostic.unhashableSetEntry();
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), entry);
+            diag.addMessage(localize_1.LocAddendum.unhashableType().format({ type: printType(type) }));
+            const message = isDictKey ? localize_1.LocMessage.unhashableDictKey() : localize_1.LocMessage.unhashableSetEntry();
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), entry);
         }
     }
     function inferTypeArgFromExpectedEntryType(inferenceContext, entryTypes, isNarrowable) {
@@ -9882,6 +9917,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }, {
             dependentType: expectedType,
+            allowDiagnostics: !forceSpeculative && !isDiagnosticSuppressedForNode(node) && !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
         });
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* FunctionTypeFlags.PartiallyEvaluated */;
@@ -9895,13 +9931,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = false;
         let typeErrors = false;
         // If any of the "for" clauses are marked async or any of the "if" clauses
-        // or the final expression contain an "await" operator anywhere within
-        // the expression, it is treated as an async generator.
-        let isAsync = node.forIfNodes.some((comp) => {
+        // or any clause other than the leftmost "for" contain an "await" operator,
+        // it is treated as an async generator.
+        let isAsync = node.forIfNodes.some((comp, index) => {
             if (comp.nodeType === 33 /* ParseNodeType.ListComprehensionFor */ && comp.isAsync) {
                 return true;
             }
-            return ParseTreeUtils.containsAwaitNode(comp);
+            return index > 0 && ParseTreeUtils.containsAwaitNode(comp);
         });
         let type = types_1.UnknownType.create();
         if (ParseTreeUtils.containsAwaitNode(node.expression)) {
@@ -9934,7 +9970,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // to avoid confusion.
         const simplifiedType = (0, types_1.removeUnbound)(type);
         if ((0, types_1.isUnknown)(simplifiedType)) {
-            addDiagnostic(diagLevel, rule, localize_1.Localizer.Diagnostic.typeUnknown().format({ name: nameValue }), errorNode);
+            addDiagnostic(rule, localize_1.LocMessage.typeUnknown().format({ name: nameValue }), errorNode);
         }
         else if ((0, typeUtils_1.isPartlyUnknown)(simplifiedType)) {
             // If ignoreEmptyContainers is true, don't report the problem for
@@ -9942,11 +9978,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // only if the assigned value is used later.
             if (!ignoreEmptyContainers || !(0, types_1.isClassInstance)(type) || !type.isEmptyContainer) {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.typeOfSymbol().format({
+                diagAddendum.addMessage(localize_1.LocAddendum.typeOfSymbol().format({
                     name: nameValue,
                     type: printType(simplifiedType, { expandTypeAlias: true }),
                 }));
-                addDiagnostic(diagLevel, rule, localize_1.Localizer.Diagnostic.typePartiallyUnknown().format({ name: nameValue }) + diagAddendum.getString(), errorNode);
+                addDiagnostic(rule, localize_1.LocMessage.typePartiallyUnknown().format({ name: nameValue }) + diagAddendum.getString(), errorNode);
             }
         }
     }
@@ -10052,7 +10088,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateTypeArg(argResult, options) {
         if (argResult.typeList) {
             if (!(options === null || options === void 0 ? void 0 : options.allowTypeArgList)) {
-                addError(localize_1.Localizer.Diagnostic.typeArgListNotAllowed(), argResult.node);
+                addError(localize_1.LocMessage.typeArgListNotAllowed(), argResult.node);
                 return false;
             }
             else {
@@ -10063,23 +10099,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, typeUtils_1.isEllipsisType)(argResult.type)) {
             if (!(options === null || options === void 0 ? void 0 : options.allowTypeArgList)) {
-                addError(localize_1.Localizer.Diagnostic.ellipsisContext(), argResult.node);
+                addError(localize_1.LocMessage.ellipsisContext(), argResult.node);
                 return false;
             }
         }
         if ((0, types_1.isModule)(argResult.type)) {
-            addError(localize_1.Localizer.Diagnostic.moduleAsType(), argResult.node);
+            addError(localize_1.LocMessage.moduleAsType(), argResult.node);
             return false;
         }
         if ((0, types_1.isParamSpec)(argResult.type)) {
             if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
-                addError(localize_1.Localizer.Diagnostic.paramSpecContext(), argResult.node);
+                addError(localize_1.LocMessage.paramSpecContext(), argResult.node);
                 return false;
             }
         }
         if ((0, types_1.isVariadicTypeVar)(argResult.type) && !argResult.type.isVariadicInUnion) {
             if (!(options === null || options === void 0 ? void 0 : options.allowVariadicTypeVar)) {
-                addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), argResult.node);
+                addError(localize_1.LocMessage.typeVarTupleContext(), argResult.node);
                 return false;
             }
             else {
@@ -10087,12 +10123,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowEmptyTuple) && argResult.isEmptyTupleShorthand) {
-            addError(localize_1.Localizer.Diagnostic.zeroLengthTupleNotAllowed(), argResult.node);
+            addError(localize_1.LocMessage.zeroLengthTupleNotAllowed(), argResult.node);
             return false;
         }
         if ((0, types_1.isUnpackedClass)(argResult.type)) {
             if (!(options === null || options === void 0 ? void 0 : options.allowUnpackedTuples)) {
-                addError(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument(), argResult.node);
+                addError(localize_1.LocMessage.unpackedArgInTypeArgument(), argResult.node);
                 return false;
             }
         }
@@ -10117,13 +10153,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Make sure we have at most one unpacked variadic type variable.
                     if (sawUnpacked) {
                         if (!reportedUnpackedError) {
-                            addError(localize_1.Localizer.Diagnostic.variadicTypeArgsTooMany(), entry.node);
+                            addError(localize_1.LocMessage.variadicTypeArgsTooMany(), entry.node);
                             reportedUnpackedError = true;
                         }
                     }
                     sawUnpacked = true;
                 };
                 typeList.forEach((entry, index) => {
+                    var _a;
                     let entryType = entry.type;
                     let paramCategory = 0 /* ParameterCategory.Simple */;
                     const paramName = `__p${index.toString()}`;
@@ -10135,7 +10172,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if (validateTypeArg(entry, { allowUnpackedTuples: true })) {
                         if ((0, types_1.isUnpackedClass)(entryType)) {
                             paramCategory = 1 /* ParameterCategory.ArgsList */;
-                            noteSawUnpacked(entry);
+                            if ((_a = entryType.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.some((typeArg) => (0, types_1.isVariadicTypeVar)(typeArg.type) || typeArg.isUnbounded)) {
+                                noteSawUnpacked(entry);
+                            }
                         }
                     }
                     else {
@@ -10188,7 +10227,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.callableFirstArg(), typeArgs[0].node);
+                    addError(localize_1.LocMessage.callableFirstArg(), typeArgs[0].node);
                 }
             }
             if (typeArgs.length > 1) {
@@ -10199,12 +10238,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 functionType.details.declaredReturnType = (0, typeUtils_1.convertToInstance)(typeArg1Type);
             }
             else {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.callableSecondArg(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.callableSecondArg(), errorNode);
                 functionType.details.declaredReturnType = types_1.UnknownType.create();
             }
             if (typeArgs.length > 2) {
-                addError(localize_1.Localizer.Diagnostic.callableExtraArgs(), typeArgs[2].node);
+                addError(localize_1.LocMessage.callableExtraArgs(), typeArgs[2].node);
             }
         }
         else {
@@ -10220,13 +10258,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
             if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-                addError(localize_1.Localizer.Diagnostic.optionalExtraArgs(), errorNode);
+                addError(localize_1.LocMessage.optionalExtraArgs(), errorNode);
                 return types_1.UnknownType.create();
             }
             return classType;
         }
         if (typeArgs.length > 1) {
-            addError(localize_1.Localizer.Diagnostic.optionalExtraArgs(), errorNode);
+            addError(localize_1.LocMessage.optionalExtraArgs(), errorNode);
             return types_1.UnknownType.create();
         }
         let typeArg0Type = typeArgs[0].type;
@@ -10239,7 +10277,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create()]);
         if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
-            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, unionClassType);
+            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(unionClassType));
         }
         return optionalType;
     }
@@ -10262,7 +10300,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Creates a type that represents a Literal.
     function createLiteralType(classType, node, flags) {
         if (node.items.length === 0) {
-            addError(localize_1.Localizer.Diagnostic.literalEmptyArgs(), node.baseExpression);
+            addError(localize_1.LocMessage.literalEmptyArgs(), node.baseExpression);
             return types_1.UnknownType.create();
         }
         // As per the specification, we support None, int, bool, str, bytes literals
@@ -10272,11 +10310,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let type;
             const itemExpr = item.valueExpression;
             if (item.argumentCategory !== 0 /* ArgumentCategory.Simple */) {
-                addError(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument(), itemExpr);
+                addError(localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
                 type = types_1.UnknownType.create();
             }
             else if (item.name) {
-                addError(localize_1.Localizer.Diagnostic.keywordArgInTypeArgument(), itemExpr);
+                addError(localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
                 type = types_1.UnknownType.create();
             }
             else if (itemExpr.nodeType === 48 /* ParseNodeType.StringList */) {
@@ -10340,7 +10378,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (!type) {
-                addError(localize_1.Localizer.Diagnostic.literalUnsupportedType(), item);
+                addError(localize_1.LocMessage.literalUnsupportedType(), item);
                 type = types_1.UnknownType.create();
             }
             literalTypes.push(type);
@@ -10351,26 +10389,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function createClassVarType(classType, errorNode, typeArgs, flags) {
         var _a;
         if (flags & 131072 /* EvaluatorFlags.DisallowClassVar */) {
-            addError(localize_1.Localizer.Diagnostic.classVarNotAllowed(), errorNode);
+            addError(localize_1.LocMessage.classVarNotAllowed(), errorNode);
             return types_1.AnyType.create();
         }
         if (!typeArgs) {
             return classType;
         }
         else if (typeArgs.length === 0) {
-            addError(localize_1.Localizer.Diagnostic.classVarFirstArgMissing(), errorNode);
+            addError(localize_1.LocMessage.classVarFirstArgMissing(), errorNode);
             return types_1.UnknownType.create();
         }
         else if (typeArgs.length > 1) {
-            addError(localize_1.Localizer.Diagnostic.classVarTooManyArgs(), typeArgs[1].node);
+            addError(localize_1.LocMessage.classVarTooManyArgs(), typeArgs[1].node);
             return types_1.UnknownType.create();
         }
         const type = typeArgs[0].type;
         // A ClassVar should not allow TypeVars or generic types parameterized
         // by TypeVars.
         if ((0, typeUtils_1.requiresSpecialization)(type, { ignorePseudoGeneric: true, ignoreSelf: true })) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classVarWithTypeVar(), (_a = typeArgs[0].node) !== null && _a !== void 0 ? _a : errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classVarWithTypeVar(), (_a = typeArgs[0].node) !== null && _a !== void 0 ? _a : errorNode);
         }
         return type;
     }
@@ -10378,18 +10415,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // isn't a generic type and therefore doesn't have a typeParameter.
     // We'll abuse our internal types a bit by specializing it with
     // a type argument anyway.
-    function createTypeGuardType(errorNode, classType, typeArgs, flags) {
+    function createTypeGuardType(classType, errorNode, typeArgs, flags) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
         if (!typeArgs) {
             if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-                addError(localize_1.Localizer.Diagnostic.typeGuardArgCount(), errorNode);
+                addError(localize_1.LocMessage.typeGuardArgCount(), errorNode);
             }
             return classType;
         }
         else if (typeArgs.length !== 1) {
-            addError(localize_1.Localizer.Diagnostic.typeGuardArgCount(), errorNode);
+            addError(localize_1.LocMessage.typeGuardArgCount(), errorNode);
             return types_1.UnknownType.create();
         }
         const convertedTypeArgs = typeArgs.map((typeArg) => {
@@ -10399,10 +10436,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function createSelfType(classType, errorNode, typeArgs, flags) {
         var _a;
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         // Self doesn't support any type arguments.
         if (typeArgs) {
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                 name: classType.details.name,
             }), (_a = typeArgs[0].node) !== null && _a !== void 0 ? _a : errorNode);
         }
@@ -10416,13 +10452,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const enclosingClassTypeResult = enclosingClass ? getTypeOfClass(enclosingClass) : undefined;
         if (!enclosingClassTypeResult) {
             if ((flags & (256 /* EvaluatorFlags.ExpectingTypeAnnotation */ | 128 /* EvaluatorFlags.ExpectingInstantiableType */)) !== 0) {
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeContext(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeContext(), errorNode);
             }
             return types_1.UnknownType.create();
         }
         else if ((0, typeUtils_1.isInstantiableMetaclass)(enclosingClassTypeResult.classType)) {
             // If `Self` appears within a metaclass, it is considered illegal.
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeMetaclass(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeMetaclass(), errorNode);
             return types_1.UnknownType.create();
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
@@ -10433,7 +10469,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!isInnerFunction) {
                 // Check for static methods.
                 if (functionInfo.flags & 4 /* FunctionTypeFlags.StaticMethod */) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeContext(), errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeContext(), errorNode);
                     return types_1.UnknownType.create();
                 }
                 if (enclosingFunction.parameters.length > 0) {
@@ -10444,7 +10480,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             associateTypeVarsWithScope: true,
                         });
                         if (!(0, types_1.isTypeVar)(annotationType) || !annotationType.details.isSynthesizedSelf) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeWithTypedSelfOrCls(), errorNode);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeWithTypedSelfOrCls(), errorNode);
                         }
                     }
                 }
@@ -10461,10 +10497,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (!typeArgs || typeArgs.length !== 1) {
             addError(classType.details.name === 'ReadOnly'
-                ? localize_1.Localizer.Diagnostic.readOnlyArgCount()
+                ? localize_1.LocMessage.readOnlyArgCount()
                 : classType.details.name === 'Required'
-                    ? localize_1.Localizer.Diagnostic.requiredArgCount()
-                    : localize_1.Localizer.Diagnostic.notRequiredArgCount(), errorNode);
+                    ? localize_1.LocMessage.requiredArgCount()
+                    : localize_1.LocMessage.notRequiredArgCount(), errorNode);
             return { type: classType };
         }
         const typeArgType = typeArgs[0].type;
@@ -10503,10 +10539,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (!isUsageLegal) {
             addError(classType.details.name === 'ReadOnly'
-                ? localize_1.Localizer.Diagnostic.readOnlyNotInTypedDict()
+                ? localize_1.LocMessage.readOnlyNotInTypedDict()
                 : classType.details.name === 'Required'
-                    ? localize_1.Localizer.Diagnostic.requiredNotInTypedDict()
-                    : localize_1.Localizer.Diagnostic.notRequiredNotInTypedDict(), errorNode);
+                    ? localize_1.LocMessage.requiredNotInTypedDict()
+                    : localize_1.LocMessage.notRequiredNotInTypedDict(), errorNode);
             return { type: types_1.ClassType.cloneForSpecialization(classType, [(0, typeUtils_1.convertToInstance)(typeArgType)], !!typeArgs) };
         }
         return { type: typeArgType, isReadOnly, isRequired, isNotRequired };
@@ -10519,14 +10555,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return classType;
         }
         if (!typeArgs || typeArgs.length !== 1) {
-            addError(localize_1.Localizer.Diagnostic.unpackArgCount(), errorNode);
+            addError(localize_1.LocMessage.unpackArgCount(), errorNode);
             return types_1.UnknownType.create();
         }
         let typeArgType = typeArgs[0].type;
         if ((0, types_1.isUnion)(typeArgType) && typeArgType.subtypes.length === 1) {
             typeArgType = typeArgType.subtypes[0];
         }
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         if ((flags & 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */) !== 0) {
             if ((0, types_1.isInstantiableClass)(typeArgType) && !typeArgType.includeSubclasses && (0, typeUtils_1.isTupleClass)(typeArgType)) {
                 return types_1.ClassType.cloneForUnpacked(typeArgType);
@@ -10534,75 +10569,75 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isVariadicTypeVar)(typeArgType) && !typeArgType.isVariadicUnpacked) {
                 return types_1.TypeVarType.cloneForUnpacked(typeArgType);
             }
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackExpectedTypeVarTuple(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
             return types_1.UnknownType.create();
         }
         if ((flags & 8388608 /* EvaluatorFlags.AllowUnpackedTypedDict */) !== 0) {
             if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isTypedDictClass(typeArgType)) {
                 return types_1.ClassType.cloneForUnpacked(typeArgType);
             }
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackExpectedTypedDict(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypedDict(), errorNode);
             return types_1.UnknownType.create();
         }
-        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackNotAllowed(), errorNode);
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackNotAllowed(), errorNode);
         return types_1.UnknownType.create();
     }
     // Creates a "Final" type.
     function createFinalType(classType, errorNode, typeArgs, flags) {
         if (flags & 16 /* EvaluatorFlags.DisallowFinal */) {
-            addError(localize_1.Localizer.Diagnostic.finalContext(), errorNode);
-            return types_1.AnyType.create();
+            addError(localize_1.LocMessage.finalContext(), errorNode);
+            return classType;
         }
         if (!typeArgs || typeArgs.length === 0) {
             return classType;
         }
         if (typeArgs.length > 1) {
-            addError(localize_1.Localizer.Diagnostic.finalTooManyArgs(), errorNode);
+            addError(localize_1.LocMessage.finalTooManyArgs(), errorNode);
         }
-        return typeArgs[0].type;
+        return types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType);
     }
-    function createConcatenateType(errorNode, classType, typeArgs, flags) {
+    function createConcatenateType(classType, errorNode, typeArgs, flags) {
         if ((flags & 134217728 /* EvaluatorFlags.AllowConcatenate */) === 0) {
-            addError(localize_1.Localizer.Diagnostic.concatenateContext(), errorNode);
+            addError(localize_1.LocMessage.concatenateContext(), errorNode);
             return types_1.AnyType.create();
         }
         if (!typeArgs || typeArgs.length === 0) {
-            addError(localize_1.Localizer.Diagnostic.concatenateTypeArgsMissing(), errorNode);
+            addError(localize_1.LocMessage.concatenateTypeArgsMissing(), errorNode);
         }
         else {
             typeArgs.forEach((typeArg, index) => {
                 if (index === typeArgs.length - 1) {
                     if (!(0, types_1.isParamSpec)(typeArg.type) && !(0, typeUtils_1.isEllipsisType)(typeArg.type)) {
-                        addError(localize_1.Localizer.Diagnostic.concatenateParamSpecMissing(), typeArg.node);
+                        addError(localize_1.LocMessage.concatenateParamSpecMissing(), typeArg.node);
                     }
                 }
                 else {
                     if ((0, types_1.isParamSpec)(typeArg.type)) {
-                        addError(localize_1.Localizer.Diagnostic.paramSpecContext(), typeArg.node);
+                        addError(localize_1.LocMessage.paramSpecContext(), typeArg.node);
                     }
                     else if ((0, types_1.isUnpackedVariadicTypeVar)(typeArg.type)) {
-                        addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), typeArg.node);
+                        addError(localize_1.LocMessage.typeVarTupleContext(), typeArg.node);
                     }
                     else if ((0, types_1.isUnpackedClass)(typeArg.type)) {
-                        addError(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument(), typeArg.node);
+                        addError(localize_1.LocMessage.unpackedArgInTypeArgument(), typeArg.node);
                     }
                 }
             });
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function createAnnotatedType(errorNode, typeArgs) {
+    function createAnnotatedType(classType, errorNode, typeArgs) {
         if (typeArgs && typeArgs.length < 2) {
-            addError(localize_1.Localizer.Diagnostic.annotatedTypeArgMissing(), errorNode);
+            addError(localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
         }
         if (!typeArgs || typeArgs.length === 0) {
             return { type: types_1.AnyType.create() };
         }
         if (typeArgs[0].typeList) {
-            addError(localize_1.Localizer.Diagnostic.typeArgListNotAllowed(), typeArgs[0].node);
+            addError(localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[0].node);
         }
         return {
-            type: types_1.TypeBase.cloneForAnnotated(typeArgs[0].type),
+            type: types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType),
             isReadOnly: typeArgs[0].isReadOnly,
             isRequired: typeArgs[0].isRequired,
             isNotRequired: typeArgs[0].isNotRequired,
@@ -10622,7 +10657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const noteSawUnpacked = (typeArg) => {
                     if (sawUnpacked) {
                         if (!reportedUnpackedError) {
-                            addError(localize_1.Localizer.Diagnostic.variadicTypeArgsTooMany(), typeArg.node);
+                            addError(localize_1.LocMessage.variadicTypeArgsTooMany(), typeArg.node);
                             reportedUnpackedError = true;
                         }
                     }
@@ -10631,33 +10666,39 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 let reportedUnpackedError = false;
                 // Verify that we didn't receive any inappropriate types.
                 typeArgs.forEach((typeArg, index) => {
+                    var _a;
                     (0, debug_1.assert)(typeArgs !== undefined);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         if (!isTupleTypeParam) {
                             if (!allowParamSpec) {
-                                addError(localize_1.Localizer.Diagnostic.ellipsisContext(), typeArg.node);
+                                addError(localize_1.LocMessage.ellipsisContext(), typeArg.node);
                             }
                         }
                         else if (typeArgs.length !== 2 || index !== 1) {
-                            addError(localize_1.Localizer.Diagnostic.ellipsisSecondArg(), typeArg.node);
+                            addError(localize_1.LocMessage.ellipsisSecondArg(), typeArg.node);
                         }
                         else {
-                            if ((0, types_1.isTypeVar)(typeArgs[0].type) &&
-                                (0, types_1.isVariadicTypeVar)(typeArgs[0].type) &&
-                                !typeArgs[0].type.isVariadicInUnion) {
-                                addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), typeArgs[0].node);
+                            if ((0, types_1.isVariadicTypeVar)(typeArgs[0].type) && !typeArgs[0].type.isVariadicInUnion) {
+                                addError(localize_1.LocMessage.typeVarTupleContext(), typeArgs[0].node);
+                            }
+                            else if ((0, types_1.isUnpackedClass)(typeArgs[0].type)) {
+                                addError(localize_1.LocMessage.ellipsisAfterUnpacked(), typeArg.node);
                             }
                         }
                     }
                     else if ((0, types_1.isParamSpec)(typeArg.type) && allowParamSpec) {
                         // Nothing to do - this is allowed.
                     }
-                    else if ((0, types_1.isVariadicTypeVar)(typeArg.type) && paramLimit === undefined) {
-                        noteSawUnpacked(typeArg);
+                    else if (paramLimit === undefined && (0, types_1.isVariadicTypeVar)(typeArg.type)) {
+                        if (!typeArg.type.isVariadicInUnion) {
+                            noteSawUnpacked(typeArg);
+                        }
                         validateVariadicTypeVarIsUnpacked(typeArg.type, typeArg.node);
                     }
-                    else if (paramLimit === undefined && (0, types_1.isUnpacked)(typeArg.type)) {
-                        noteSawUnpacked(typeArg);
+                    else if (paramLimit === undefined && (0, types_1.isUnpackedClass)(typeArg.type)) {
+                        if ((_a = typeArg.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.some((typeArg) => (0, types_1.isVariadicTypeVar)(typeArg.type) || typeArg.isUnbounded)) {
+                            noteSawUnpacked(typeArg);
+                        }
                         validateTypeArg(typeArg, { allowUnpackedTuples: true });
                     }
                     else {
@@ -10670,7 +10711,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Make sure the argument list count is correct.
         if (paramLimit !== undefined) {
             if (typeArgs && typeArgTypes.length > paramLimit) {
-                addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                addError(localize_1.LocMessage.typeArgsTooMany().format({
                     name: classType.aliasName || classType.details.name,
                     expected: paramLimit,
                     received: typeArgTypes.length,
@@ -10698,9 +10739,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (tupleTypeArgTypes.length === 1 && !tupleTypeArgTypes[0].isUnbounded) {
                             tupleTypeArgTypes[0] = { type: tupleTypeArgTypes[0].type, isUnbounded: true };
                         }
-                        else {
-                            addError(localize_1.Localizer.Diagnostic.ellipsisSecondArg(), typeArg.node);
-                        }
                     }
                     else if ((0, types_1.isUnpackedClass)(typeArg.type) && typeArg.type.tupleTypeArguments) {
                         (0, collectionUtils_1.appendArray)(tupleTypeArgTypes, typeArg.type.tupleTypeArguments);
@@ -10730,7 +10768,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
             if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-                addError(localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
+                addError(localize_1.LocMessage.unionTypeArgCount(), errorNode);
                 return types_1.NeverType.createNever();
             }
             return classType;
@@ -10753,7 +10791,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     allowSingleTypeArg = true;
                 }
                 else {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionUnpackedTuple(), errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTuple(), errorNode);
                     types.push(types_1.UnknownType.create());
                 }
             }
@@ -10766,7 +10804,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         allowSingleTypeArg = true;
                     }
                     else {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionUnpackedTypeVarTuple(), errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTypeVarTuple(), errorNode);
                         typeArgType = types_1.UnknownType.create();
                     }
                 }
@@ -10777,11 +10815,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // is allowed if it's an unpacked variadic type var or tuple. None is also allowed
         // since it is used to define NoReturn in typeshed stubs).
         if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
         }
         let unionType = (0, types_1.combineTypes)(types);
         if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
-            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, unionClassType);
+            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(unionClassType));
         }
         return unionType;
     }
@@ -10793,7 +10831,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
             if ((flags & (256 /* EvaluatorFlags.ExpectingTypeAnnotation */ | 262144 /* EvaluatorFlags.DisallowNakedGeneric */)) !== 0) {
-                addError(localize_1.Localizer.Diagnostic.genericTypeArgMissing(), errorNode);
+                addError(localize_1.LocMessage.genericTypeArgMissing(), errorNode);
             }
             return classType;
         }
@@ -10801,16 +10839,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeArgs) {
             // Make sure there's at least one type arg.
             if (typeArgs.length === 0) {
-                addError(localize_1.Localizer.Diagnostic.genericTypeArgMissing(), errorNode);
+                addError(localize_1.LocMessage.genericTypeArgMissing(), errorNode);
             }
             // Make sure that all of the type args are typeVars and are unique.
             typeArgs.forEach((typeArg) => {
                 if (!(0, types_1.isTypeVar)(typeArg.type)) {
-                    addError(localize_1.Localizer.Diagnostic.genericTypeArgTypeVar(), typeArg.node);
+                    addError(localize_1.LocMessage.genericTypeArgTypeVar(), typeArg.node);
                 }
                 else {
                     if (uniqueTypeVars.some((t) => (0, types_1.isTypeSame)(t, typeArg.type))) {
-                        addError(localize_1.Localizer.Diagnostic.genericTypeArgUnique(), typeArg.node);
+                        addError(localize_1.LocMessage.genericTypeArgUnique(), typeArg.node);
                     }
                     uniqueTypeVars.push(typeArg.type);
                 }
@@ -10859,14 +10897,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Verify that we have at most one variadic type variable.
         const variadics = typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
         if (variadics.length > 1) {
-            addError(localize_1.Localizer.Diagnostic.variadicTypeParamTooManyAlias().format({
+            addError(localize_1.LocMessage.variadicTypeParamTooManyAlias().format({
                 names: variadics.map((v) => `"${v.details.name}"`).join(', '),
             }), errorNode);
         }
         if (!isPep695Syntax && !isPep695TypeVarType) {
             const boundTypeVars = typeParameters.filter((typeVar) => typeVar.scopeId !== typeAliasScopeId && typeVar.scopeType === 0 /* TypeVarScopeType.Class */);
             if (boundTypeVars.length > 0) {
-                addError(localize_1.Localizer.Diagnostic.genericTypeAliasBoundTypeVar().format({
+                addError(localize_1.LocMessage.genericTypeAliasBoundTypeVar().format({
                     names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
                 }), errorNode);
             }
@@ -11081,7 +11119,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (isDeclaredTypeAlias(node.leftExpression)) {
                     typeAliasNameNode = node.leftExpression.valueExpression;
                     if (!isLegalTypeAliasExpressionForm(node.rightExpression)) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), node.rightExpression);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
                     }
                 }
                 else if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
@@ -11132,7 +11170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 rightHandType = srcType;
                 if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && !node.typeAnnotationComment) {
                     rightHandType =
-                        (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node.leftExpression, () => rightHandType)) !== null && _a !== void 0 ? _a : rightHandType;
+                        (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node, node.leftExpression, () => rightHandType)) !== null && _a !== void 0 ? _a : rightHandType;
                 }
                 if (typeAliasNameNode) {
                     // If this was a speculative type alias, it becomes a real type alias
@@ -11144,7 +11182,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         /* isPep695TypeVarType */ false);
                         (0, debug_1.assert)(typeAliasTypeVar !== undefined);
                         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
                                 name: typeAliasNameNode.value,
                             }), node.rightExpression);
                             rightHandType = types_1.UnknownType.create();
@@ -11243,7 +11281,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         aliasType = transformTypeForTypeAlias(aliasType, nameNode, nameNode, isPep695Syntax, 
         /* isPep695TypeVarType */ true, typeParameters, typeParamNodes);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
                 name: nameNode.value,
             }), valueNode);
             aliasType = types_1.UnknownType.create();
@@ -11364,7 +11402,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argType = types_1.UnknownType.create();
                     }
                     else {
-                        argType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(arg.valueExpression, exprFlags).type);
+                        argType = getTypeOfExpression(arg.valueExpression, exprFlags).type;
+                        if ((0, types_1.isTypeVar)(argType) && argType.specialForm && types_1.TypeBase.isInstance(argType.specialForm)) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.baseClassInvalid(), arg);
+                            argType = types_1.UnknownType.create();
+                        }
+                        argType = makeTopLevelTypeVarsConcrete(argType);
                     }
                     // In some stub files, classes are conditionally defined (e.g. based
                     // on platform type). We'll assume that the conditional logic is correct
@@ -11386,7 +11429,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     : types_1.UnknownType.create();
                         }
                         else if (!(0, types_1.isInstantiableClass)(argType)) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.baseClassInvalid(), arg);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.baseClassInvalid(), arg);
                             argType = types_1.UnknownType.create();
                         }
                         else {
@@ -11401,7 +11444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 if (!fileInfo.isStubFile &&
                                     !types_1.ClassType.isTypingExtensionClass(argType) &&
                                     fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_7) {
-                                    addError(localize_1.Localizer.Diagnostic.protocolIllegal(), arg.valueExpression);
+                                    addError(localize_1.LocMessage.protocolIllegal(), arg.valueExpression);
                                 }
                                 classType.details.flags |= 8192 /* ClassTypeFlags.ProtocolClass */;
                             }
@@ -11426,19 +11469,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // Validate that the class isn't deriving from itself, creating a
                             // circular dependency.
                             if ((0, typeUtils_1.derivesFromClassRecursive)(argType, classType, /* ignoreUnknown */ true)) {
-                                addError(localize_1.Localizer.Diagnostic.baseClassCircular(), arg);
+                                addError(localize_1.LocMessage.baseClassCircular(), arg);
                                 argType = types_1.UnknownType.create();
                             }
                             // If the class is attempting to derive from a TypeAliasType,
                             // generate an error.
                             if (argType.specialForm && types_1.ClassType.isBuiltIn(argType.specialForm, 'TypeAliasType')) {
-                                addError(localize_1.Localizer.Diagnostic.typeAliasTypeBaseClass(), arg);
+                                addError(localize_1.LocMessage.typeAliasTypeBaseClass(), arg);
                                 argType = types_1.UnknownType.create();
                             }
                         }
                     }
                     if ((0, types_1.isUnknown)(argType)) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedBaseClass, diagnosticRules_1.DiagnosticRule.reportUntypedBaseClass, localize_1.Localizer.Diagnostic.baseClassUnknown(), arg);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUntypedBaseClass, localize_1.LocMessage.baseClassUnknown(), arg);
                     }
                     // Check for a duplicate class.
                     if (classType.details.baseClasses.some((prevBaseClass) => {
@@ -11446,7 +11489,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             (0, types_1.isInstantiableClass)(argType) &&
                             types_1.ClassType.isSameGenericClass(argType, prevBaseClass));
                     })) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateBaseClass(), arg.name || arg);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.duplicateBaseClass(), arg.name || arg);
                     }
                     classType.details.baseClasses.push(argType);
                     if ((0, types_1.isInstantiableClass)(argType)) {
@@ -11467,7 +11510,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         if (types_1.ClassType.isFinal(argType)) {
                             const className = printObjectTypeForClass(argType);
-                            addError(localize_1.Localizer.Diagnostic.baseClassFinal().format({ type: className }), arg.valueExpression);
+                            addError(localize_1.LocMessage.baseClassFinal().format({ type: className }), arg.valueExpression);
                         }
                     }
                     (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
@@ -11475,12 +11518,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (types_1.ClassType.isBuiltIn(argType, 'Generic')) {
                             // 'Generic' is implicitly added if type parameter syntax is used.
                             if (node.typeParameters) {
-                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericBaseClassNotAllowed(), arg.valueExpression);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericBaseClassNotAllowed(), arg.valueExpression);
                             }
                             else {
                                 if (!genericTypeParameters) {
                                     if (protocolTypeParameters) {
-                                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateGenericAndProtocolBase(), arg.valueExpression);
+                                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.duplicateGenericAndProtocolBase(), arg.valueExpression);
                                     }
                                     genericTypeParameters = [];
                                     (0, typeUtils_1.addTypeVarsToListIfUnique)(genericTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
@@ -11492,12 +11535,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             argType.typeArguments.length > 0) {
                             if (!protocolTypeParameters) {
                                 if (genericTypeParameters) {
-                                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.duplicateGenericAndProtocolBase(), arg.valueExpression);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.duplicateGenericAndProtocolBase(), arg.valueExpression);
                                 }
                                 protocolTypeParameters = [];
                                 (0, typeUtils_1.addTypeVarsToListIfUnique)(protocolTypeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
                                 if (node.typeParameters && protocolTypeParameters.length > 0) {
-                                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolBaseClassWithTypeArgs(), arg.valueExpression);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.protocolBaseClassWithTypeArgs(), arg.valueExpression);
                                     protocolTypeParameters = [];
                                 }
                             }
@@ -11510,19 +11553,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // PEP 589 specifies that the parameter must be either True or False.
                         const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
                         if (constArgValue === undefined) {
-                            addError(localize_1.Localizer.Diagnostic.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
+                            addError(localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
                         }
                         else if (arg.name.value === 'total' && !constArgValue) {
                             classType.details.flags |= 256 /* ClassTypeFlags.CanOmitDictValues */;
                         }
                     }
                     else {
-                        addError(localize_1.Localizer.Diagnostic.typedDictInitsubclassParameter().format({ name: arg.name.value }), arg);
+                        addError(localize_1.LocMessage.typedDictInitsubclassParameter().format({ name: arg.name.value }), arg);
                     }
                 }
                 else if (arg.name.value === 'metaclass') {
                     if (metaclassNode) {
-                        addError(localize_1.Localizer.Diagnostic.metaclassDuplicate(), arg);
+                        addError(localize_1.LocMessage.metaclassDuplicate(), arg);
                     }
                     else {
                         metaclassNode = arg.valueExpression;
@@ -11554,7 +11597,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 });
                 if (derivesFromNamedTuple && foundIllegalBaseClass) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.namedTupleMultipleInheritance(), node.name);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleMultipleInheritance(), node.name);
                 }
             }
             // Make sure we don't have 'object' derive from itself. Infinite
@@ -11578,7 +11621,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Make sure there's at most one variadic type parameter.
             const variadics = classType.details.typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
             if (variadics.length > 1) {
-                addError(localize_1.Localizer.Diagnostic.variadicTypeParamTooManyClass().format({
+                addError(localize_1.LocMessage.variadicTypeParamTooManyClass().format({
                     names: variadics.map((v) => `"${v.details.name}"`).join(', '),
                 }), node.name, textRange_1.TextRange.combine(node.arguments) || node.name);
             }
@@ -11593,7 +11636,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 validateTypeParameterDefault(bestErrorNode, typeParam, classType.details.typeParameters.slice(0, index), classType.details.typeVarScopeId);
             });
             if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
-                addError(localize_1.Localizer.Diagnostic.methodOrdering(), node.name);
+                addError(localize_1.LocMessage.methodOrdering(), node.name);
             }
             // The scope for this class becomes the "fields" for the corresponding type.
             const innerScope = ScopeUtils.getScopeForNode(node.suite);
@@ -11663,14 +11706,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
                 if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
                     if ((0, typeUtils_1.requiresSpecialization)(metaclassType, { ignorePseudoGeneric: true })) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.metaclassIsGeneric(), metaclassNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.metaclassIsGeneric(), metaclassNode);
                     }
                     classType.details.declaredMetaclass = metaclassType;
                     if ((0, types_1.isInstantiableClass)(metaclassType)) {
-                        if (types_1.ClassType.isBuiltIn(metaclassType, 'EnumMeta')) {
+                        if ((0, enums_1.isEnumMetaclass)(metaclassType)) {
                             classType.details.flags |= 1048576 /* ClassTypeFlags.EnumClass */;
                         }
-                        else if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
+                        if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
                             classType.details.flags |= 1024 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                     }
@@ -11689,7 +11732,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                     // Report this error only on the first unknown type.
                     if (!foundUnknown) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedClassDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedClassDecorator, localize_1.Localizer.Diagnostic.classDecoratorTypeUnknown(), node.decorators[i].expression);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUntypedClassDecorator, localize_1.LocMessage.classDecoratorTypeUnknown(), node.decorators[i].expression);
                         foundUnknown = true;
                     }
                 }
@@ -11734,11 +11777,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         !types_1.ClassType.isTypedDictClass(baseClass) &&
                         !types_1.ClassType.isBuiltIn(baseClass, ['_TypedDict', 'Generic'])) {
                         foundInvalidBaseClass = true;
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictBaseClass().format({ type: baseClass.details.name }));
+                        diag.addMessage(localize_1.LocAddendum.typedDictBaseClass().format({ type: baseClass.details.name }));
                     }
                 });
                 if (foundInvalidBaseClass) {
-                    addError(localize_1.Localizer.Diagnostic.typedDictBaseClass() + diag.getString(), node.name);
+                    addError(localize_1.LocMessage.typedDictBaseClass() + diag.getString(), node.name);
                 }
                 (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, (0, types_1.isClass)(decoratedType) && types_1.ClassType.isFinal(decoratedType));
             }
@@ -11814,7 +11857,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !typeParam.details.isSynthesizedSelf) {
             const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType && param.scopeId === scopeId);
             if (typeVarWithDefault) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarWithoutDefault().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithoutDefault().format({
                     name: typeParam.details.name,
                     other: typeVarWithDefault.details.name,
                 }), errorNode);
@@ -11827,9 +11870,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (invalidTypeVars.size > 0) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             invalidTypeVars.forEach((name) => {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarDefaultOutOfScope().format({ name }));
+                diag.addMessage(localize_1.LocAddendum.typeVarDefaultOutOfScope().format({ name }));
             });
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultInvalidTypeVar().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultInvalidTypeVar().format({
                 name: typeParam.details.name,
             }) + diag.getString(), errorNode);
         }
@@ -11851,11 +11894,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 param.computedVariance = 1 /* Variance.Unknown */;
             }
         });
-        // Replace all of the type parameters with invariant TypeVars.
-        const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
-        const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
         const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', 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;
@@ -11866,7 +11906,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             // 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;
                 }
@@ -11875,20 +11915,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // 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 = assignClassToSelf(srcType, destType, /* ignoreBaseClassVariance */ false);
+            const isDestSubtypeOfSrc = assignClassToSelf(srcType, destType, 3 /* Variance.Covariant */, 
+            /* ignoreBaseClassVariance */ false);
             let inferredVariance;
             if (isDestSubtypeOfSrc) {
                 inferredVariance = 3 /* Variance.Covariant */;
             }
             else {
-                const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType, /* ignoreBaseClassVariance */ false);
+                const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType, 4 /* Variance.Contravariant */, 
+                /* ignoreBaseClassVariance */ false);
                 if (isSrcSubtypeOfDest) {
                     inferredVariance = 4 /* Variance.Contravariant */;
                 }
@@ -11938,11 +11979,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         else if (!(0, typeUtils_1.derivesFromClassRecursive)(effectiveMetaclass, baseClassMeta, /* ignoreUnknown */ false)) {
                             if (!reportedMetaclassConflict) {
                                 const diag = new diagnostic_1.DiagnosticAddendum();
-                                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.metaclassConflict().format({
+                                diag.addMessage(localize_1.LocAddendum.metaclassConflict().format({
                                     metaclass1: printType((0, typeUtils_1.convertToInstance)(effectiveMetaclass)),
                                     metaclass2: printType((0, typeUtils_1.convertToInstance)(baseClassMeta)),
                                 }));
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.metaclassConflict() + diag.getString(), errorNode);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.metaclassConflict() + diag.getString(), errorNode);
                                 // Don't report more than once.
                                 reportedMetaclassConflict = true;
                             }
@@ -11952,9 +11993,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveMetaclass = baseClassMeta ? types_1.UnknownType.create() : undefined;
                         break;
                     }
-                    if (types_1.ClassType.isEnumClass(baseClass)) {
-                        classType.details.flags |= 1048576 /* ClassTypeFlags.EnumClass */;
-                    }
                 }
                 else {
                     // If one of the base classes is unknown, then the effective
@@ -11984,10 +12022,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         if (missingFromGeneric.length > 0) {
             const diag = new diagnostic_1.DiagnosticAddendum();
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarsMissing().format({
+            diag.addMessage(localize_1.LocAddendum.typeVarsMissing().format({
                 names: missingFromGeneric.map((typeVar) => `"${typeVar.details.name}"`).join(', '),
             }));
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarsNotInGenericOrProtocol() + diag.getString(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarsNotInGenericOrProtocol() + diag.getString(), errorNode);
         }
     }
     // Records the fact that the specified class requires "deferred completion" because
@@ -12033,7 +12071,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function completeClassTypeDeferred(type, errorNode) {
         // Recompute the MRO linearization.
         if (!(0, typeUtils_1.computeMroLinearization)(type)) {
-            addError(localize_1.Localizer.Diagnostic.methodOrdering(), errorNode);
+            addError(localize_1.LocMessage.methodOrdering(), errorNode);
         }
         // Recompute the effective metaclass.
         computeEffectiveMetaclass(type, errorNode);
@@ -12090,7 +12128,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 paramMap.delete(arg.name.value);
                             }
                             else {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: arg.name.value }), (_c = arg.name) !== null && _c !== void 0 ? _c : errorNode);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramNameMissing().format({ name: arg.name.value }), (_c = arg.name) !== null && _c !== void 0 ? _c : errorNode);
                             }
                         }
                     });
@@ -12105,9 +12143,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                     if (unassignedParams.length > 0) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
-                            ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
-                            : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
+                            ? localize_1.LocMessage.argMissingForParam().format({ name: missingParamNames })
+                            : localize_1.LocMessage.argMissingForParams().format({ names: missingParamNames }), errorNode);
                     }
                 }
             }
@@ -12127,7 +12165,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* typeVarContext */ undefined, 
                     /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()));
                     if (callResult.argumentErrors) {
-                        const diag = addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initSubclassCallFailed(), node.name);
+                        const diag = addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initSubclassCallFailed(), node.name);
                         const initSubclassFunction = (0, types_1.isOverloadedFunction)(initSubclassMethodType)
                             ? types_1.OverloadedFunctionType.getOverloads(initSubclassMethodType)[0]
                             : initSubclassMethodType;
@@ -12135,7 +12173,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             ? initSubclassFunction.details.declaration
                             : undefined;
                         if (diag && initSubclassDecl) {
-                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.initSubclassLocation().format({
+                            diag.addRelatedInfo(localize_1.LocAddendum.initSubclassLocation().format({
                                 name: printType((0, typeUtils_1.convertToInstance)(initSubclassMethodInfo.classType)),
                             }), initSubclassDecl.uri, initSubclassDecl.range);
                         }
@@ -12151,6 +12189,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
     }
     function getTypeOfFunction(node) {
+        var _a;
         initializedBasicTypes(node);
         // Is this predecorated function type cached?
         let functionType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
@@ -12189,8 +12228,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
                 if (!foundUnknown) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedFunctionDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedFunctionDecorator, localize_1.Localizer.Diagnostic.functionDecoratorTypeUnknown(), node.decorators[i].expression);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUntypedFunctionDecorator, localize_1.LocMessage.functionDecoratorTypeUnknown(), node.decorators[i].expression);
                     foundUnknown = true;
                 }
             }
@@ -12199,6 +12237,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 decoratedType = newDecoratedType;
             }
         }
+        // In case this is an enum class and a method wrapped in an enum.member.
+        decoratedType =
+            (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node, node.name, () => decoratedType)) !== null && _a !== void 0 ? _a : decoratedType;
         // See if there are any overloads provided by previous function declarations.
         if ((0, types_1.isFunction)(decoratedType)) {
             decoratedType.details.deprecatedMessage = functionType.details.deprecatedMessage;
@@ -12295,7 +12336,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 firstCommentAnnotationIndex = 0;
             }
             else if (received !== expected) {
-                addError(localize_1.Localizer.Diagnostic.annotatedParamCountMismatch().format({
+                addError(localize_1.LocMessage.annotatedParamCountMismatch().format({
                     expected,
                     received,
                 }), node.functionAnnotationComment);
@@ -12347,9 +12388,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (paramTypeNode) {
-                annotatedType = getTypeOfParameterAnnotation(paramTypeNode, param.category);
+                if ((functionInfo.flags & 524288 /* FunctionTypeFlags.NoTypeCheck */) !== 0) {
+                    annotatedType = types_1.UnknownType.create();
+                }
+                else {
+                    annotatedType = getTypeOfParameterAnnotation(paramTypeNode, param.category);
+                }
                 if ((0, types_1.isVariadicTypeVar)(annotatedType) && !annotatedType.isVariadicUnpacked) {
-                    addError(localize_1.Localizer.Diagnostic.unpackedTypeVarTupleExpected().format({
+                    addError(localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
                         name1: annotatedType.details.name,
                         name2: annotatedType.details.name,
                     }), paramTypeNode);
@@ -12394,7 +12440,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     if (!assignType(annotatedType, defaultValueType, diagAddendum, typeVarContext)) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramAssignmentMismatch().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.paramAssignmentMismatch().format({
                             sourceType: printType(defaultValueType),
                             paramType: printType(annotatedType),
                         }) + diagAddendum.getString(), param.defaultValue);
@@ -12842,6 +12888,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                             isIncomplete = true;
                                         }
                                         let returnType = returnTypeResult.type;
+                                        // If the type is a special form, use the special form instead.
+                                        if (returnType.specialForm) {
+                                            returnType = returnType.specialForm;
+                                        }
                                         // If the return type includes an instance of a class with isEmptyContainer
                                         // set, clear that because we don't want this flag to "leak" into the
                                         // inferred return type.
@@ -13039,8 +13089,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let exprType = exprTypeResult.type;
         const isAsync = node.parent && node.parent.nodeType === 58 /* ParseNodeType.With */ && !!node.parent.isAsync;
         if ((0, typeUtils_1.isOptionalType)(exprType)) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportOptionalContextManager, diagnosticRules_1.DiagnosticRule.reportOptionalContextManager, localize_1.Localizer.Diagnostic.noneNotUsableWith(), node.expression);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalContextManager, localize_1.LocMessage.noneNotUsableWith(), node.expression);
             exprType = (0, typeUtils_1.removeNoneFromUnion)(exprType);
         }
         // Verify that the target has an __enter__ or __aenter__ method defined.
@@ -13064,12 +13113,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!isAsync) {
                     if (getTypeOfMagicMethodCall(subtype, '__aenter__', [], node.expression, 
                     /* inferenceContext */ undefined)) {
-                        additionalHelp.addMessage(localize_1.Localizer.DiagnosticAddendum.asyncHelp());
+                        additionalHelp.addMessage(localize_1.LocAddendum.asyncHelp());
                     }
                 }
             }
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotUsableWith().format({ type: printType(subtype), method: enterMethodName }) +
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotUsableWith().format({ type: printType(subtype), method: enterMethodName }) +
                 additionalHelp.getString(), node.expression);
             return types_1.UnknownType.create();
         });
@@ -13088,8 +13136,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return;
                 }
             }
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotUsableWith().format({ type: printType(subtype), method: exitMethodName }), node.expression);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotUsableWith().format({ type: printType(subtype), method: exitMethodName }), node.expression);
         });
         if (node.target) {
             assignTypeToExpression(node.target, scopedType, !!exprTypeResult.isIncomplete, node.target);
@@ -13183,7 +13230,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     reportError = true;
                 }
                 if (reportError) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.importSymbolUnknown().format({ name: node.name.value }), node.name);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, localize_1.LocMessage.importSymbolUnknown().format({ name: node.name.value }), node.name);
                 }
             }
             if (!symbolType) {
@@ -13264,7 +13311,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!assignType(declaredType, importedSymbolType, diagAddendum)) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatchWildcard().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatchWildcard().format({
                             ...printSrcDestTypes(importedSymbolType, declaredType),
                             name,
                         }) + diagAddendum.getString(), node, (_b = node.wildcardToken) !== null && _b !== void 0 ? _b : node);
@@ -13347,18 +13394,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (node.nodeType === 23 /* ParseNodeType.ImportFromAs */) {
             if (resolvedAliasInfo.isPrivate) {
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportPrivateUsage, diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.Localizer.Diagnostic.privateUsedOutsideOfModule().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.LocMessage.privateUsedOutsideOfModule().format({
                     name: node.name.value,
                 }), node.name);
             }
             if (resolvedAliasInfo.privatePyTypedImporter) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 if (resolvedAliasInfo.privatePyTypedImported) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.privateImportFromPyTypedSource().format({
+                    diag.addMessage(localize_1.LocAddendum.privateImportFromPyTypedSource().format({
                         module: resolvedAliasInfo.privatePyTypedImported,
                     }));
                 }
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportPrivateImportUsage, diagnosticRules_1.DiagnosticRule.reportPrivateImportUsage, localize_1.Localizer.Diagnostic.privateImportFromPyTypedModule().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateImportUsage, localize_1.LocMessage.privateImportFromPyTypedModule().format({
                     name: node.name.value,
                     module: resolvedAliasInfo.privatePyTypedImporter,
                 }) + diag.getString(), node.name);
@@ -13450,9 +13497,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // See if the expression is part of a pattern used in a case statement.
         const possibleCaseNode = ParseTreeUtils.getParentNodeOfType(node, 64 /* ParseNodeType.Case */);
         if (possibleCaseNode) {
-            const caseNode = possibleCaseNode;
-            if (ParseTreeUtils.isNodeContainedWithin(node, caseNode.pattern)) {
-                evaluateTypesForCaseStatement(caseNode);
+            if (ParseTreeUtils.isNodeContainedWithin(node, possibleCaseNode.pattern)) {
+                evaluateTypesForCaseStatement(possibleCaseNode);
                 return;
             }
         }
@@ -13856,13 +13902,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 case 'Never': {
                     if (typeArgs && typeArgs.length > 0) {
-                        addError(localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({ name: 'Never' }), typeArgs[0].node);
+                        addError(localize_1.LocMessage.typeArgsExpectingNone().format({ name: 'Never' }), typeArgs[0].node);
                     }
                     return { type: types_1.NeverType.createNever() };
                 }
                 case 'NoReturn': {
                     if (typeArgs && typeArgs.length > 0) {
-                        addError(localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({ name: 'NoReturn' }), typeArgs[0].node);
+                        addError(localize_1.LocMessage.typeArgsExpectingNone().format({ name: 'NoReturn' }), typeArgs[0].node);
                     }
                     return { type: types_1.NeverType.createNoReturn() };
                 }
@@ -13885,7 +13931,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((flags &
                         (67108864 /* EvaluatorFlags.DisallowNonTypeSpecialForms */ | 256 /* EvaluatorFlags.ExpectingTypeAnnotation */)) !==
                         0) {
-                        addError(localize_1.Localizer.Diagnostic.protocolNotAllowed(), errorNode);
+                        addError(localize_1.LocMessage.protocolNotAllowed(), errorNode);
                     }
                     return {
                         type: createSpecialType(classType, typeArgs, 
@@ -13897,7 +13943,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((flags &
                         (67108864 /* EvaluatorFlags.DisallowNonTypeSpecialForms */ | 256 /* EvaluatorFlags.ExpectingTypeAnnotation */)) !==
                         0) {
-                        addError(localize_1.Localizer.Diagnostic.typedDictNotAllowed(), errorNode);
+                        addError(localize_1.LocMessage.typedDictNotAllowed(), errorNode);
                     }
                     break;
                 }
@@ -13905,7 +13951,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((flags &
                         (67108864 /* EvaluatorFlags.DisallowNonTypeSpecialForms */ | 256 /* EvaluatorFlags.ExpectingTypeAnnotation */)) !==
                         0) {
-                        addError(localize_1.Localizer.Diagnostic.literalNotAllowed(), errorNode);
+                        addError(localize_1.LocMessage.literalNotAllowed(), errorNode);
                     }
                     break;
                 }
@@ -13927,13 +13973,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return { type: createFinalType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Annotated': {
-                    return createAnnotatedType(errorNode, typeArgs);
+                    return createAnnotatedType(classType, errorNode, typeArgs);
                 }
                 case 'Concatenate': {
-                    return { type: createConcatenateType(errorNode, classType, typeArgs, flags) };
+                    return { type: createConcatenateType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'TypeGuard': {
-                    return { type: createTypeGuardType(errorNode, classType, typeArgs, flags) };
+                    return { type: createTypeGuardType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Unpack': {
                     return { type: createUnpackType(classType, errorNode, typeArgs, flags) };
@@ -13967,7 +14013,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeArgs.length >= 1) {
                     // Treat type[function] as illegal.
                     if ((0, types_1.isFunction)(typeArgs[0].type) || (0, types_1.isOverloadedFunction)(typeArgs[0].type)) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationWithCallable(), typeArgs[0].node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
                         return { type: types_1.UnknownType.create() };
                     }
                 }
@@ -14010,7 +14056,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Classes that accept inlined type dict type args allow only one.
             if (typeArgs[0].inlinedTypeDict) {
                 if (typeArgs.length > 1) {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
                         name: classType.aliasName || classType.details.name,
                         expected: 1,
                         received: typeArgCount,
@@ -14020,14 +14066,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (typeParameters.length === 0) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                             name: classType.aliasName || classType.details.name,
                         }), typeArgs[typeParameters.length].node);
                     }
                     else if (typeParameters.length !== 1 || !(0, types_1.isParamSpec)(typeParameters[0])) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
                             name: classType.aliasName || classType.details.name,
                             expected: typeParameters.length,
                             received: typeArgCount,
@@ -14037,8 +14082,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (typeArgCount < minTypeArgCount) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsTooFew().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooFew().format({
                     name: classType.aliasName || classType.details.name,
                     expected: minTypeArgCount,
                     received: typeArgCount,
@@ -14089,11 +14133,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (typeArgs.length > 1) {
                 const paramSpecTypeArg = typeArgs.find((typeArg) => (0, types_1.isParamSpec)(typeArg.type));
                 if (paramSpecTypeArg) {
-                    addError(localize_1.Localizer.Diagnostic.paramSpecContext(), paramSpecTypeArg.node);
+                    addError(localize_1.LocMessage.paramSpecContext(), paramSpecTypeArg.node);
                 }
                 const listTypeArg = typeArgs.find((typeArg) => !!typeArg.typeList);
                 if (listTypeArg) {
-                    addError(localize_1.Localizer.Diagnostic.typeArgListNotAllowed(), listTypeArg.node);
+                    addError(localize_1.LocMessage.typeArgListNotAllowed(), listTypeArg.node);
                 }
             }
         }
@@ -14179,7 +14223,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const destType = typeParameters[index];
                     const declaredVariance = destType.details.declaredVariance;
                     if (!(0, typeUtils_1.isVarianceOfTypeArgumentCompatible)(adjustedTypeArgType, declaredVariance)) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatchForClass().format({
+                        diag.addMessage(localize_1.LocAddendum.varianceMismatchForClass().format({
                             typeVarName: printType(adjustedTypeArgType),
                             className: classType.details.name,
                         }));
@@ -14193,8 +14237,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Avoid emitting this error for a partially-constructed class.
                     if (!(0, types_1.isClassInstance)(typeArgType) || !types_1.ClassType.isPartiallyEvaluated(typeArgType)) {
                         (0, debug_1.assert)(typeArgs !== undefined);
-                        const fileInfo = AnalyzerNodeInfo.getFileInfo(typeArgs[index].node);
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarAssignmentMismatch().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeVarAssignmentMismatch().format({
                             type: printType(typeArgType),
                             name: types_1.TypeVarType.getReadableName(typeParameters[index]),
                         }) + diag.getString(), typeArgs[index].node);
@@ -14671,7 +14714,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return declarations;
     }
     function getTypeForDeclaration(declaration) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         switch (declaration.type) {
             case 0 /* DeclarationType.Intrinsic */: {
                 if (declaration.intrinsicType === 'Any') {
@@ -14780,8 +14823,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (declaredType) {
                         // Apply enum transform if appropriate.
                         if (declaration.node.nodeType === 38 /* ParseNodeType.Name */) {
-                            declaredType =
-                                (_c = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, declaration.node, () => declaredType)) !== null && _c !== void 0 ? _c : declaredType;
+                            const variableNode = (_c = ParseTreeUtils.getParentNodeOfType(declaration.node, 3 /* ParseNodeType.Assignment */)) !== null && _c !== void 0 ? _c : ParseTreeUtils.getParentNodeOfType(declaration.node, 54 /* ParseNodeType.TypeAnnotation */);
+                            if (variableNode) {
+                                declaredType =
+                                    (_d = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, variableNode, declaration.node, () => declaredType)) !== null && _d !== void 0 ? _d : declaredType;
+                            }
                         }
                         if ((0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias')) {
                             return { type: undefined, isTypeAlias: true };
@@ -14811,7 +14857,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const runtimeType = getTypingType(node, runtimeClassName);
         const runtimeClass = runtimeType && (0, types_1.isInstantiableClass)(runtimeType) ? runtimeType : undefined;
-        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value, node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec, runtimeClass);
+        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value, node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec);
+        if (runtimeClass) {
+            typeVar = types_1.TypeBase.cloneAsSpecialForm(typeVar, types_1.ClassType.cloneAsInstance(runtimeClass));
+        }
         typeVar.details.isTypeParamSyntax = true;
         if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
             typeVar.details.isVariadic = true;
@@ -14830,12 +14879,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         ignorePseudoGeneric: true,
                         ignoreImplicitTypeArgs: true,
                     })) {
-                        addError(localize_1.Localizer.Diagnostic.typeVarBoundGeneric(), constraint);
+                        addError(localize_1.LocMessage.typeVarBoundGeneric(), constraint);
                     }
                     return (0, typeUtils_1.convertToInstance)(constraintType);
                 });
                 if (constraints.length < 2) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node.boundExpression).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarSingleConstraint(), node.boundExpression);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarSingleConstraint(), node.boundExpression);
                 }
                 else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
                     typeVar.details.constraints = constraints;
@@ -14844,7 +14893,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 const boundType = getTypeOfExpressionExpectingType(node.boundExpression).type;
                 if ((0, typeUtils_1.requiresSpecialization)(boundType, { ignorePseudoGeneric: true })) {
-                    addError(localize_1.Localizer.Diagnostic.typeVarConstraintGeneric(), node.boundExpression);
+                    addError(localize_1.LocMessage.typeVarConstraintGeneric(), node.boundExpression);
                 }
                 if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
                     typeVar.details.boundType = (0, typeUtils_1.convertToInstance)(boundType);
@@ -14871,12 +14920,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             if (typeVar.details.boundType) {
                 if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultBoundMismatch(), node.defaultExpression);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultBoundMismatch(), node.defaultExpression);
                 }
             }
             else if (typeVar.details.constraints.length > 0) {
                 if (!typeVar.details.constraints.some((constraint) => (0, types_1.isTypeSame)(constraint, concreteDefaultType))) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultConstraintMismatch(), node.defaultExpression);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultConstraintMismatch(), node.defaultExpression);
                 }
             }
         }
@@ -14901,7 +14950,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeVar;
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const resolvedDecl = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
             allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
         });
@@ -15025,17 +15074,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 evaluateTypesForStatement(typeSource);
             })) === null || _c === void 0 ? void 0 : _c.type;
             if (inferredType && resolvedDecl.node.nodeType === 38 /* ParseNodeType.Name */) {
-                // See if this is an enum member. If so, we need to handle it as a special case.
-                const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, resolvedDecl.node, () => {
-                    var _a, _b;
-                    (0, debug_1.assert)(resolvedDecl.inferredTypeSource !== undefined);
-                    const inferredTypeSource = resolvedDecl.inferredTypeSource;
-                    return ((_b = (_a = evaluateTypeForSubnode(inferredTypeSource, () => {
-                        evaluateTypesForStatement(inferredTypeSource);
-                    })) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
-                });
-                if (enumMemberType) {
-                    inferredType = enumMemberType;
+                const variableNode = (_d = ParseTreeUtils.getParentNodeOfType(resolvedDecl.node, 3 /* ParseNodeType.Assignment */)) !== null && _d !== void 0 ? _d : ParseTreeUtils.getParentNodeOfType(resolvedDecl.node, 54 /* ParseNodeType.TypeAnnotation */);
+                if (variableNode) {
+                    // See if this is an enum member. If so, we need to handle it as a special case.
+                    const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, variableNode, resolvedDecl.node, () => {
+                        var _a, _b;
+                        (0, debug_1.assert)(resolvedDecl.inferredTypeSource !== undefined);
+                        const inferredTypeSource = resolvedDecl.inferredTypeSource;
+                        return ((_b = (_a = evaluateTypeForSubnode(inferredTypeSource, () => {
+                            evaluateTypesForStatement(inferredTypeSource);
+                        })) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
+                    });
+                    if (enumMemberType) {
+                        inferredType = enumMemberType;
+                    }
                 }
             }
             if (inferredType && isTypeAlias && resolvedDecl.typeAliasName) {
@@ -15738,7 +15790,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return types_1.UnknownType.create();
     }
-    function getTypeOfMemberInternal(member, selfClass) {
+    function getTypeOfMemberInternal(errorNode, member, selfClass, flags) {
         if ((0, types_1.isInstantiableClass)(member.classType)) {
             const typeResult = getEffectiveTypeOfSymbolForUsage(member.symbol);
             if (typeResult) {
@@ -15746,6 +15798,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // and cache the return type if necessary. This needs to be done
                 // prior to specializing.
                 inferReturnTypeIfNecessary(typeResult.type);
+                if (member.isInstanceMember &&
+                    (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0) {
+                    let isGenericNonCallable = false;
+                    (0, typeUtils_1.doForEachSubtype)(typeResult.type, (subtype) => {
+                        if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloadedFunction)(subtype)) {
+                            if ((0, typeUtils_1.requiresSpecialization)(typeResult.type, {
+                                ignoreSelf: true,
+                                ignoreImplicitTypeArgs: true,
+                            })) {
+                                isGenericNonCallable = true;
+                            }
+                        }
+                    });
+                    if (isGenericNonCallable && errorNode) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
+                    }
+                }
                 return {
                     type: (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.classType, selfClass),
                     isIncomplete: !!typeResult.isIncomplete,
@@ -15776,7 +15845,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return false;
             }
             if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFinalMismatch().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typedDictFinalMismatch().format({
                     sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
                     destType: printType((0, typeUtils_1.convertToInstance)(destType)),
                 }));
@@ -15809,7 +15878,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // testing to see if the metaclass matches the protocol.
         if (types_1.ClassType.isProtocolClass(destType) && !isDerivedFrom) {
             if (!(0, protocols_1.assignClassToProtocol)(evaluatorInterface, destType, types_1.ClassType.cloneAsInstance(srcType), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolIncompatible().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.protocolIncompatible().format({
                     sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
                     destType: printType((0, typeUtils_1.convertToInstance)(destType)),
                 }));
@@ -15840,7 +15909,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             destErrorTypeText = destType.details.fullName;
             srcErrorTypeText = srcType.details.fullName;
         }
-        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeIncompatible().format({
+        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeIncompatible().format({
             sourceType: srcErrorTypeText,
             destType: destErrorTypeText,
         }));
@@ -15848,7 +15917,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (types_1.ClassType.isBuiltIn(destType, 'bytes')) {
             const promotions = typePromotions.get(destType.details.fullName);
             if (promotions && promotions.some((name) => name === srcType.details.fullName)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.bytesTypePromotions());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.bytesTypePromotions());
             }
         }
         return false;
@@ -15858,98 +15927,109 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // the type parameters for the base class are honored. This is useful for
     // variance inference (PEP 695). For validation of protocol variance, we
     // want to ignore the variance for all base classes in the class hierarchy.
-    function assignClassToSelf(destType, srcType, ignoreBaseClassVariance = true, recursionCount = 0) {
+    function assignClassToSelf(destType, srcType, assumedVariance, ignoreBaseClassVariance = true, recursionCount = 0) {
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         (0, debug_1.assert)(destType.details.typeParameters.length > 0);
         const typeVarContext = new typeVarContext_1.TypeVarContext();
         let isAssignable = true;
-        destType.details.fields.forEach((symbol, name) => {
-            if (!isAssignable || symbol.isIgnoredForProtocolMatch()) {
-                return;
-            }
-            // Constructor methods are exempt from variance calculations.
-            if (name === '__new__' || name === '__init__') {
-                return;
-            }
-            const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
-            (0, debug_1.assert)(memberInfo !== undefined);
-            let destMemberType = getEffectiveTypeOfSymbol(symbol);
-            const srcMemberType = getTypeOfMember(memberInfo);
-            destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
-            // Properties require special processing.
-            if ((0, types_1.isClassInstance)(destMemberType) &&
-                types_1.ClassType.isPropertyClass(destMemberType) &&
-                (0, types_1.isClassInstance)(srcMemberType) &&
-                types_1.ClassType.isPropertyClass(srcMemberType)) {
-                if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, 
-                /* diag */ undefined, typeVarContext, 
-                /* selfTypeVarContext */ undefined, recursionCount)) {
-                    isAssignable = false;
+        // Use a try/catch block here to make sure that we reset
+        // the assignClassToSelfClass to undefined if an exception occurs.
+        try {
+            // Stash the current class type so any references to it are treated
+            // as though all TypeParameters are invariant.
+            assignClassToSelfStack.push({ class: destType, assumedVariance });
+            destType.details.fields.forEach((symbol, name) => {
+                if (!isAssignable || symbol.isIgnoredForProtocolMatch()) {
+                    return;
                 }
-            }
-            else {
-                const primaryDecl = symbol.getDeclarations()[0];
-                let flags = 0 /* AssignTypeFlags.Default */;
-                if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ &&
-                    !isFinalVariableDeclaration(primaryDecl) &&
-                    !types_1.ClassType.isFrozenDataClass(destType)) {
-                    // Class and instance variables that are mutable need to
-                    // enforce invariance. We will exempt variables that are
-                    // private or protected, since these are presumably
-                    // not modifiable outside of the class.
-                    if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
-                        flags |= 1 /* AssignTypeFlags.EnforceInvariance */;
+                // Constructor methods are exempt from variance calculations.
+                if (name === '__new__' || name === '__init__') {
+                    return;
+                }
+                const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
+                (0, debug_1.assert)(memberInfo !== undefined);
+                let destMemberType = getEffectiveTypeOfSymbol(symbol);
+                const srcMemberType = getTypeOfMember(memberInfo);
+                destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
+                // Properties require special processing.
+                if ((0, types_1.isClassInstance)(destMemberType) &&
+                    types_1.ClassType.isPropertyClass(destMemberType) &&
+                    (0, types_1.isClassInstance)(srcMemberType) &&
+                    types_1.ClassType.isPropertyClass(srcMemberType)) {
+                    if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, 
+                    /* diag */ undefined, typeVarContext, 
+                    /* selfTypeVarContext */ undefined, recursionCount)) {
+                        isAssignable = false;
                     }
                 }
-                if (!assignType(destMemberType, srcMemberType, 
-                /* diag */ undefined, typeVarContext, 
-                /* srcTypeVarContext */ undefined, flags, recursionCount)) {
-                    isAssignable = false;
+                else {
+                    const primaryDecl = symbol.getDeclarations()[0];
+                    let flags = 0 /* AssignTypeFlags.Default */;
+                    if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ &&
+                        !isFinalVariableDeclaration(primaryDecl) &&
+                        !types_1.ClassType.isFrozenDataClass(destType)) {
+                        // Class and instance variables that are mutable need to
+                        // enforce invariance. We will exempt variables that are
+                        // private or protected, since these are presumably
+                        // not modifiable outside of the class.
+                        if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
+                            flags |= 1 /* AssignTypeFlags.EnforceInvariance */;
+                        }
+                    }
+                    if (!assignType(destMemberType, srcMemberType, 
+                    /* diag */ undefined, typeVarContext, 
+                    /* srcTypeVarContext */ undefined, flags | 65536 /* AssignTypeFlags.IgnoreSelfClsParamCompatibility */, recursionCount)) {
+                        isAssignable = false;
+                    }
                 }
+            });
+            if (!isAssignable) {
+                return false;
             }
-        });
-        if (!isAssignable) {
-            return false;
-        }
-        // Now handle generic base classes.
-        destType.details.baseClasses.forEach((baseClass) => {
-            if ((0, types_1.isInstantiableClass)(baseClass) &&
-                !types_1.ClassType.isBuiltIn(baseClass, 'object') &&
-                !types_1.ClassType.isBuiltIn(baseClass, 'Protocol') &&
-                !types_1.ClassType.isBuiltIn(baseClass, 'Generic') &&
-                baseClass.details.typeParameters.length > 0) {
-                const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
-                const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
-                if (!ignoreBaseClassVariance) {
-                    specializedDestBaseClass.details.typeParameters.forEach((param, index) => {
-                        if (!param.details.isParamSpec &&
-                            !param.details.isVariadic &&
-                            !param.details.isSynthesized &&
-                            specializedSrcBaseClass.typeArguments &&
-                            index < specializedSrcBaseClass.typeArguments.length &&
-                            specializedDestBaseClass.typeArguments &&
-                            index < specializedDestBaseClass.typeArguments.length) {
-                            const paramVariance = param.details.declaredVariance;
-                            if ((0, types_1.isTypeVar)(specializedSrcBaseClass.typeArguments[index])) {
-                                if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 4 /* Variance.Contravariant */) {
-                                    isAssignable = false;
+            // Now handle generic base classes.
+            destType.details.baseClasses.forEach((baseClass) => {
+                if ((0, types_1.isInstantiableClass)(baseClass) &&
+                    !types_1.ClassType.isBuiltIn(baseClass, 'object') &&
+                    !types_1.ClassType.isBuiltIn(baseClass, 'Protocol') &&
+                    !types_1.ClassType.isBuiltIn(baseClass, 'Generic') &&
+                    baseClass.details.typeParameters.length > 0) {
+                    const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
+                    const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
+                    if (!ignoreBaseClassVariance) {
+                        specializedDestBaseClass.details.typeParameters.forEach((param, index) => {
+                            if (!param.details.isParamSpec &&
+                                !param.details.isVariadic &&
+                                !param.details.isSynthesized &&
+                                specializedSrcBaseClass.typeArguments &&
+                                index < specializedSrcBaseClass.typeArguments.length &&
+                                specializedDestBaseClass.typeArguments &&
+                                index < specializedDestBaseClass.typeArguments.length) {
+                                const paramVariance = param.details.declaredVariance;
+                                if ((0, types_1.isTypeVar)(specializedSrcBaseClass.typeArguments[index])) {
+                                    if (paramVariance === 2 /* Variance.Invariant */ ||
+                                        paramVariance === 4 /* Variance.Contravariant */) {
+                                        isAssignable = false;
+                                    }
                                 }
-                            }
-                            else if ((0, types_1.isTypeVar)(specializedDestBaseClass.typeArguments[index])) {
-                                if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 3 /* Variance.Covariant */) {
-                                    isAssignable = false;
+                                else if ((0, types_1.isTypeVar)(specializedDestBaseClass.typeArguments[index])) {
+                                    if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 3 /* Variance.Covariant */) {
+                                        isAssignable = false;
+                                    }
                                 }
                             }
-                        }
-                    });
-                }
-                if (isAssignable &&
-                    !assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, ignoreBaseClassVariance, recursionCount)) {
-                    isAssignable = false;
+                        });
+                    }
+                    if (isAssignable &&
+                        !assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, assumedVariance, ignoreBaseClassVariance, recursionCount)) {
+                        isAssignable = false;
+                    }
                 }
-            }
-        });
-        return isAssignable;
+            });
+            return isAssignable;
+        }
+        finally {
+            assignClassToSelfStack.pop();
+        }
     }
     // Adjusts the source and/or dest type arguments list to attempt to match
     // the length of the src type arguments list if the dest or source contain
@@ -15959,9 +16039,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const destUnboundedOrVariadicIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
         const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
         const srcVariadicIndex = srcTypeArgs.findIndex((t) => (0, types_1.isVariadicTypeVar)(t.type));
+        let isSrcVariadicAny = false;
         // If the src contains an unbounded type but the dest does not, it's incompatible.
         if (srcUnboundedIndex >= 0 && destUnboundedOrVariadicIndex < 0) {
-            return false;
+            // Unless the source contains an [Any, ...].
+            if ((0, types_1.isAnyOrUnknown)(srcTypeArgs[srcUnboundedIndex].type)) {
+                isSrcVariadicAny = true;
+            }
+            else {
+                return false;
+            }
         }
         if (srcUnboundedIndex >= 0) {
             // The source is unbounded, so expand the unbounded argument to try
@@ -15970,6 +16057,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             while (srcTypeArgs.length < destTypeArgs.length) {
                 srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
             }
+            if (isSrcVariadicAny && srcTypeArgs.length > destTypeArgs.length) {
+                srcTypeArgs.splice(srcUnboundedIndex, 1);
+            }
         }
         // Remove any optional parameters from the end of the two lists until the lengths match.
         while (srcTypeArgs.length > destTypeArgs.length && srcTypeArgs[srcTypeArgs.length - 1].isOptional) {
@@ -16049,7 +16139,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const entryDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                 if (!assignType(destTypeArgs[argIndex].type, srcTypeArgs[argIndex].type, entryDiag === null || entryDiag === void 0 ? void 0 : entryDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                     if (entryDiag) {
-                        entryDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleEntryTypeMismatch().format({
+                        entryDiag.addMessage(localize_1.LocAddendum.tupleEntryTypeMismatch().format({
                             entry: argIndex + 1,
                         }));
                     }
@@ -16059,12 +16149,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else {
             if (srcTypeArgs.find((t) => t.isUnbounded)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleSizeIndeterminate().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeIndeterminate().format({
                     expected: destTypeArgs.length,
                 }));
             }
             else {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleSizeMismatch().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeMismatch().format({
                     expected: destTypeArgs.length,
                     received: srcTypeArgs.length,
                 }));
@@ -16180,6 +16270,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const destTypeParams = types_1.ClassType.getTypeParameters(destType);
         let destTypeArgs;
         let srcTypeArgs;
+        // Are we performing protocol variance validation for this class? If so,
+        // treat all of the type parameters as invariant even if they are declared
+        // otherwise.
+        const assignClassToSelfInfo = assignClassToSelfStack.find((info) => types_1.ClassType.isSameGenericClass(info.class, destType));
+        const assumedVariance = assignClassToSelfInfo === null || assignClassToSelfInfo === void 0 ? void 0 : assignClassToSelfInfo.assumedVariance;
         // If either source or dest type arguments are missing, they are
         // treated as "Any", so they are assumed to be assignable.
         if (!destType.typeArguments || !srcType.typeArguments) {
@@ -16202,22 +16297,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const destTypeArg = destArgIndex >= 0 ? destTypeArgs[destArgIndex] : types_1.UnknownType.create();
             const destTypeParam = destArgIndex < destTypeParams.length ? destTypeParams[destArgIndex] : undefined;
             const assignmentDiag = new diagnostic_1.DiagnosticAddendum();
-            const variance = destTypeParam ? types_1.TypeVarType.getVariance(destTypeParam) : 3 /* Variance.Covariant */;
+            const variance = assumedVariance !== null && assumedVariance !== void 0 ? assumedVariance : (destTypeParam ? types_1.TypeVarType.getVariance(destTypeParam) : 3 /* Variance.Covariant */);
             let effectiveFlags;
             let errorSource;
             let includeDiagAddendum = true;
             if (variance === 3 /* Variance.Covariant */) {
                 effectiveFlags = flags | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
-                errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsCovariant;
+                errorSource = localize_1.LocAddendum.typeVarIsCovariant;
             }
             else if (variance === 4 /* Variance.Contravariant */) {
                 effectiveFlags =
                     (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
-                errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsContravariant;
+                errorSource = localize_1.LocAddendum.typeVarIsContravariant;
             }
             else {
                 effectiveFlags = flags | 1 /* AssignTypeFlags.EnforceInvariance */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
-                errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsInvariant;
+                errorSource = localize_1.LocAddendum.typeVarIsInvariant;
                 // Omit the diagnostic addendum for the invariant case because it's obvious
                 // why two types are not the same.
                 includeDiagAddendum = false;
@@ -16239,13 +16334,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (isCompatible && types_1.ClassType.isSameGenericClass(destType, srcType)) {
                                 // Add additional notes to help the user if this is a common type mismatch.
                                 if (types_1.ClassType.isBuiltIn(destType, 'dict') && srcArgIndex === 1) {
-                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionDict());
+                                    childDiag.addMessage(localize_1.LocAddendum.invariantSuggestionDict());
                                 }
                                 else if (types_1.ClassType.isBuiltIn(destType, 'list')) {
-                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionList());
+                                    childDiag.addMessage(localize_1.LocAddendum.invariantSuggestionList());
                                 }
                                 else if (types_1.ClassType.isBuiltIn(destType, 'set')) {
-                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionSet());
+                                    childDiag.addMessage(localize_1.LocAddendum.invariantSuggestionSet());
                                 }
                             }
                         }
@@ -16477,7 +16572,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return true;
                 }
                 if (!(0, types_1.isUnion)(destType)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                     return false;
                 }
             }
@@ -16570,7 +16665,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (assignType(destType, (0, typeUtils_1.convertToInstantiable)(typeTypeArg), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                     return true;
                 }
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
         }
@@ -16583,7 +16678,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (types_1.ClassType.isProtocolClass(expandedSrcType) &&
                         (0, types_1.isInstantiableClass)(srcType) &&
                         !srcType.includeSubclasses) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolSourceIsNotConcrete().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.protocolSourceIsNotConcrete().format({
                             sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
                             destType: printType(destType),
                         }));
@@ -16595,7 +16690,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* reportErrorsUsingObjType */ false)) {
                     return true;
                 }
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
             else if ((0, types_1.isClassInstance)(expandedSrcType) && (0, typeUtils_1.isMetaclassInstance)(expandedSrcType)) {
@@ -16607,7 +16702,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* reportErrorsUsingObjType */ false)) {
                         return true;
                     }
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                     return false;
                 }
             }
@@ -16646,7 +16741,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (destType.literalValue !== undefined) {
                     const srcLiteral = concreteSrcType.literalValue;
                     if (srcLiteral === undefined || !types_1.ClassType.isLiteralValueSame(concreteSrcType, destType)) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.literalAssignmentMismatch().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.literalAssignmentMismatch().format({
                             sourceType: printType(srcType),
                             destType: printType(destType),
                         }));
@@ -16768,7 +16863,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 });
                 if (filteredOverloads.length === 0) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.noOverloadAssignable().format({ type: printType(destType) }));
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.noOverloadAssignable().format({ type: printType(destType) }));
                     return false;
                 }
                 if (destTypeVarContext) {
@@ -16813,7 +16908,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             if (!isAssignable) {
                 if (overloadDiag) {
-                    overloadDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.overloadNotAssignable().format({
+                    overloadDiag.addMessage(localize_1.LocAddendum.overloadNotAssignable().format({
                         name: destType.overloads[0].details.name,
                     }));
                 }
@@ -16836,10 +16931,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if ((0, typeUtils_1.isNoneInstance)(destType)) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.assignToNone());
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.assignToNone());
             return false;
         }
-        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
         return false;
     }
     function assignFromUnionType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
@@ -17014,7 +17109,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */) !== 0 && matchedSomeSubtypes) {
                 return true;
             }
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
             return false;
         }
         return true;
@@ -17105,7 +17200,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
             if (isIncompatible) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
             return true;
@@ -17185,7 +17280,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (!foundMatch) {
             if (diag && diagAddendum) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 diag.addAddendum(diagAddendum);
             }
             return false;
@@ -17308,7 +17403,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // of the lambda itself.
             if (!(0, types_1.isTypeSame)(destType, srcType)) {
                 if (diag && paramIndex !== undefined) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramAssignment().format({
+                    diag.addMessage(localize_1.LocAddendum.paramAssignment().format({
                         index: paramIndex + 1,
                         sourceType: printType(destType),
                         destType: printType(srcType),
@@ -17420,6 +17515,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const positionalsToMatch = Math.min(destPositionalCount, srcPositionalCount);
         // Match positional parameters.
         for (let paramIndex = 0; paramIndex < positionalsToMatch; paramIndex++) {
+            if (paramIndex === 0 &&
+                destType.details.methodClass &&
+                (flags & 65536 /* AssignTypeFlags.IgnoreSelfClsParamCompatibility */) !== 0) {
+                if (types_1.FunctionType.isInstanceMethod(destType) || types_1.FunctionType.isClassMethod(destType)) {
+                    continue;
+                }
+            }
             // Skip over the *args parameter since it's handled separately below.
             if (paramIndex === destParamDetails.argsIndex) {
                 continue;
@@ -17438,13 +17540,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     destParam.param.category !== 1 /* ParameterCategory.ArgsList */ &&
                     srcParam.param.category !== 1 /* ParameterCategory.ArgsList */) {
                     if (srcParam.source === parameterUtils_1.ParameterSource.PositionOnly) {
-                        diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamPositionOnly().format({
+                        diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamPositionOnly().format({
                             name: destParamName,
                         }));
                         canAssign = false;
                     }
                     else if (destParamName !== srcParamName) {
-                        diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamName().format({
+                        diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamName().format({
                             srcName: srcParamName,
                             destName: destParamName,
                         }));
@@ -17455,7 +17557,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!!destParam.param.hasDefault &&
                 !srcParam.param.hasDefault &&
                 paramIndex !== srcParamDetails.argsIndex) {
-                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamDefaultMissing().format({
+                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
                     name: srcParamName,
                 }));
                 canAssign = false;
@@ -17484,7 +17586,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
             destParamDetails.firstPositionOrKeywordIndex < srcParamDetails.positionOnlyParamCount &&
             !targetIncludesParamSpec) {
-            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.argsPositionOnly().format({
+            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.argsPositionOnly().format({
                 expected: srcParamDetails.positionOnlyParamCount,
                 received: destParamDetails.firstPositionOrKeywordIndex,
             }));
@@ -17499,7 +17601,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (destPositionalCount < nonDefaultSrcParamCount) {
                         if (destParamDetails.firstPositionOrKeywordIndex > 0 &&
                             destParamDetails.firstPositionOrKeywordIndex < srcPositionalCount) {
-                            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionTooFewParams().format({
+                            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionTooFewParams().format({
                                 expected: nonDefaultSrcParamCount,
                                 received: destPositionalCount,
                             }));
@@ -17533,7 +17635,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     const destParamType = destParamDetails.params[paramIndex].type;
                     if ((0, types_1.isVariadicTypeVar)(destParamType) && !(0, types_1.isVariadicTypeVar)(srcArgsType)) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarTupleRequiresKnownLength());
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeVarTupleRequiresKnownLength());
                         canAssign = false;
                     }
                     else {
@@ -17542,7 +17644,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         if (destParamDetails.params[paramIndex].source !== parameterUtils_1.ParameterSource.PositionOnly &&
                             srcParamDetails.kwargsIndex === undefined) {
-                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.namedParamMissingInSource().format({
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
                                 name: (_e = destParamDetails.params[paramIndex].param.name) !== null && _e !== void 0 ? _e : '',
                             }));
                             canAssign = false;
@@ -17558,7 +17660,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     adjDestPositionalCount--;
                 }
                 if (srcPositionalCount < adjDestPositionalCount) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionTooManyParams().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.functionTooManyParams().format({
                         expected: srcPositionalCount,
                         received: destPositionalCount,
                     }));
@@ -17594,7 +17696,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             srcType.details.paramSpec === undefined &&
             destParamDetails.argsIndex !== undefined &&
             !destParamDetails.hasUnpackedVariadicTypeVar) {
-            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.argsParamMissing().format({
+            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.argsParamMissing().format({
                 paramName: (_f = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _f !== void 0 ? _f : '',
             }));
             canAssign = false;
@@ -17630,7 +17732,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (!destParamInfo) {
                                 if (destParamDetails.kwargsIndex === undefined && !srcParamInfo.param.hasDefault) {
                                     if (paramDiag && srcParamDetails.firstKeywordOnlyIndex !== undefined) {
-                                        paramDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.namedParamMissingInDest().format({
+                                        paramDiag.addMessage(localize_1.LocAddendum.namedParamMissingInDest().format({
                                             name: srcParamInfo.param.name,
                                         }));
                                     }
@@ -17651,7 +17753,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 if (!assignFunctionParameter(destParamInfo.type, srcParamType, 
                                 /* paramIndex */ undefined, paramDiag === null || paramDiag === void 0 ? void 0 : paramDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                                     if (paramDiag) {
-                                        paramDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.namedParamTypeMismatch().format({
+                                        paramDiag.addMessage(localize_1.LocAddendum.namedParamTypeMismatch().format({
                                             name: srcParamInfo.param.name,
                                             sourceType: printType(specializedDestParamType),
                                             destType: printType(srcParamType),
@@ -17660,7 +17762,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     canAssign = false;
                                 }
                                 if (!!destParamInfo.param.hasDefault && !srcParamInfo.param.hasDefault) {
-                                    diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamDefaultMissing().format({
+                                    diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
                                         name: srcParamInfo.param.name,
                                     }));
                                     canAssign = false;
@@ -17681,7 +17783,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     destParamMap.delete(paramName);
                 }
                 else {
-                    diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.namedParamMissingInSource().format({ name: paramName }));
+                    diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({ name: paramName }));
                     canAssign = false;
                 }
             });
@@ -17697,7 +17799,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 srcParamDetails.kwargsIndex === undefined &&
                 srcType.details.paramSpec === undefined &&
                 destParamDetails.kwargsIndex !== undefined) {
-                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.kwargsParamMissing().format({
+                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.kwargsParamMissing().format({
                     paramName: destParamDetails.params[destParamDetails.kwargsIndex].param.name,
                 }));
                 canAssign = false;
@@ -17828,7 +17930,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (!isReturnTypeCompatible) {
                     if (returnDiag) {
-                        returnDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionReturnTypeMismatch().format({
+                        returnDiag.addMessage(localize_1.LocAddendum.functionReturnTypeMismatch().format({
                             sourceType: printType(srcReturnType),
                             destType: printType(destReturnType),
                         }));
@@ -17967,7 +18069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If we're overriding a non-method with a method, report it as an error.
         // This occurs when a non-property overrides a property.
         if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloadedFunction)(baseMethod)) {
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideType().format({ type: printType(baseMethod) }));
+            diag.addMessage(localize_1.LocAddendum.overrideType().format({ type: printType(baseMethod) }));
             return false;
         }
         if ((0, types_1.isFunction)(baseMethod)) {
@@ -17983,7 +18085,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             })) {
                 return true;
             }
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNoOverloadMatches());
+            diag.addMessage(localize_1.LocAddendum.overrideNoOverloadMatches());
             return false;
         }
         // For a non-overloaded method overriding an overloaded method, the
@@ -18028,7 +18130,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             if (matchIndex < previousMatchIndex) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadOrder());
+                diag.addMessage(localize_1.LocAddendum.overrideOverloadOrder());
                 return false;
             }
             previousMatchIndex = matchIndex;
@@ -18041,7 +18143,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return isOverrideMethodApplicable(overload, baseClass);
                 })) {
                 // We didn't find matches for all of the base overloads.
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch());
+                diag.addMessage(localize_1.LocAddendum.overrideOverloadNoMatch());
                 return false;
             }
         }
@@ -18097,19 +18199,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // an incompatible type.
             if (types_1.FunctionType.isStaticMethod(baseMethod)) {
                 if (!types_1.FunctionType.isStaticMethod(overrideMethod)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideNotStaticMethod());
                     canOverride = false;
                 }
             }
             else if (types_1.FunctionType.isClassMethod(baseMethod)) {
                 if (!types_1.FunctionType.isClassMethod(overrideMethod)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideNotClassMethod());
                     canOverride = false;
                 }
             }
             else if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
                 if (!types_1.FunctionType.isInstanceMethod(overrideMethod)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideNotInstanceMethod());
                     canOverride = false;
                 }
             }
@@ -18124,7 +18226,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                     for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
                         if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
-                            localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
+                            localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamDetails.params[i].type),
                                 overrideType: printType(overrideArgsType),
@@ -18148,7 +18250,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (foundParamCountMismatch) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overridePositionalParamCount().format({
                     baseCount: baseParamDetails.params.length,
                     overrideCount: overrideParamDetails.params.length,
                 }));
@@ -18176,13 +18278,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (overrideParam.category === 0 /* ParameterCategory.Simple */) {
                         if (enforceParamNames && !baseParam.isNameSynthesized) {
                             if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
-                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                                     index: i + 1,
                                     baseName: baseParam.name || '*',
                                 }));
                             }
                             else {
-                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
+                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamName().format({
                                     index: i + 1,
                                     baseName: baseParam.name || '*',
                                     overrideName: overrideParam.name || '*',
@@ -18196,7 +18298,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     i >= baseParamDetails.positionOnlyParamCount) {
                     if (!baseParam.isNameSynthesized &&
                         baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                             index: i + 1,
                             baseName: baseParam.name || '*',
                         }));
@@ -18211,7 +18313,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!exemptSelfClsParam || (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar)) {
                         if (baseParam.category !== overrideParam.category ||
                             !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
-                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamType),
                                 overrideType: printType(overrideParamType),
@@ -18221,7 +18323,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (baseParamDetails.params[i].param.hasDefault &&
                         !overrideParamDetails.params[i].param.hasDefault) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNoDefault().format({
                             index: i + 1,
                         }));
                         canOverride = false;
@@ -18231,7 +18333,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Check for a *args match.
             if (baseParamDetails.argsIndex !== undefined) {
                 if (overrideParamDetails.argsIndex === undefined) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNameMissing().format({
                         name: (_a = baseParamDetails.params[baseParamDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : '?',
                     }));
                     canOverride = false;
@@ -18241,7 +18343,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
                     if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
                     /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                             name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
                             baseType: printType(baseParamType),
                             overrideType: printType(overrideParamType),
@@ -18259,7 +18361,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 var _a, _b, _c;
                 const overrideParamInfo = overrideKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
                 if (!overrideParamInfo && overrideParamDetails.kwargsIndex === undefined) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNameMissing().format({
                         name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
                     }));
                     canOverride = false;
@@ -18270,7 +18372,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
                     }
                     if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                             name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
                             baseType: printType(paramInfo.type),
                             overrideType: printType(targetParamType),
@@ -18279,7 +18381,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (overrideParamInfo) {
                         if (paramInfo.param.hasDefault && !overrideParamInfo.param.hasDefault) {
-                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordNoDefault().format({
                                 name: (_c = overrideParamInfo.param.name) !== null && _c !== void 0 ? _c : '?',
                             }));
                             canOverride = false;
@@ -18295,7 +18397,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!baseParamInfo) {
                     if (baseParamDetails.kwargsIndex === undefined) {
                         if (!paramInfo.param.hasDefault) {
-                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNameExtra().format({
                                 name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
                             }));
                             canOverride = false;
@@ -18305,7 +18407,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // Verify that if the base method has a **kwargs parameter, the override does too.
             if (baseParamDetails.kwargsIndex !== undefined && overrideParamDetails.kwargsIndex === undefined) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.kwargsParamMissing().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.kwargsParamMissing().format({
                     paramName: baseParamDetails.params[baseParamDetails.kwargsIndex].param.name,
                 }));
                 canOverride = false;
@@ -18320,7 +18422,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 overrideParamDetails.kwargsIndex !== undefined &&
                 (0, types_1.isAnyOrUnknown)(overrideParamDetails.params[overrideParamDetails.kwargsIndex].type);
             if (!overrideHasArgsKwargs) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecMissingInOverride());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.paramSpecMissingInOverride());
                 canOverride = false;
             }
         }
@@ -18328,7 +18430,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);
         if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideReturnType().format({
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),
                 overrideType: printType(overrideReturnType),
             }));
@@ -18364,7 +18466,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Avoid adding a message that will confuse users if the TypeVar was
                 // synthesized for internal purposes.
                 if (!destType.details.isSynthesized) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeBound().format({
+                    diag.addMessage(localize_1.LocAddendum.typeBound().format({
                         sourceType: printType(effectiveSrcType),
                         destType: printType(destType.details.boundType),
                         name: types_1.TypeVarType.getReadableName(destType),
@@ -18383,14 +18485,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'Concatenate')) {
                 return srcType;
             }
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeParamSpec().format({
+            diag.addMessage(localize_1.LocAddendum.typeParamSpec().format({
                 type: printType(srcType),
                 name: types_1.TypeVarType.getReadableName(destType),
             }));
             return undefined;
         }
         if ((0, types_1.isTypeVar)(srcType) && srcType.details.isParamSpec) {
-            diag.addMessage(localize_1.Localizer.Diagnostic.paramSpecContext());
+            diag.addMessage(localize_1.LocMessage.paramSpecContext());
             return undefined;
         }
         // If there are no constraints, we're done.
@@ -18424,61 +18526,38 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return bestConstraintSoFar;
             }
         }
-        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeConstrainedTypeVar().format({
+        diag.addMessage(localize_1.LocAddendum.typeConstrainedTypeVar().format({
             type: printType(srcType),
             name: types_1.TypeVarType.getReadableName(destType),
         }));
         return undefined;
     }
-    function getAbstractMethods(classType) {
+    // Returns a list of unimplemented abstract symbols (methods or variables) for
+    // the specified class.
+    function getAbstractSymbols(classType) {
         const symbolTable = new Map();
         types_1.ClassType.getReverseMro(classType).forEach((mroClass) => {
             if ((0, types_1.isInstantiableClass)(mroClass)) {
-                // See if this class is introducing a new abstract method that has not been
-                // introduced previously or if it is overriding an abstract method with
+                // See if this class is introducing a new abstract symbol that has not been
+                // introduced previously or if it is overriding an abstract symbol with
                 // a non-abstract one.
                 mroClass.details.fields.forEach((symbol, symbolName) => {
-                    // We do a quick-and-dirty evaluation of methods based on
-                    // decorators to determine which ones are abstract. This allows
-                    // us to avoid evaluating the full function types.
-                    // Handle named tuple fields as though they are class members here.
-                    // We model them as instance variables, but they're actually implemented
-                    // using class variable descriptors, and these overwrite a class variable
-                    // abstract method.
-                    if (symbol.isClassMember() || symbol.isNamedTupleMemberMember()) {
-                        let isAbstract;
-                        const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-                        if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                            const functionFlags = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, decl.node, true).flags;
-                            isAbstract = !!(functionFlags & 8 /* FunctionTypeFlags.AbstractMethod */);
-                        }
-                        else {
-                            // If a symbol is overridden by a non-function, it is no longer
-                            // considered abstract. This can happen in some code, for example,
-                            // when a base class declares an abstract property and a subclass
-                            // "overrides" it with an instance variable.
-                            isAbstract = false;
-                        }
-                        if (isAbstract) {
-                            symbolTable.set(symbolName, {
-                                symbol,
-                                symbolName,
-                                classType: mroClass,
-                            });
-                        }
-                        else {
-                            symbolTable.delete(symbolName);
-                        }
+                    const abstractSymbolInfo = getAbstractSymbolInfo(mroClass, symbolName);
+                    if (abstractSymbolInfo) {
+                        symbolTable.set(symbolName, abstractSymbolInfo);
+                    }
+                    else {
+                        symbolTable.delete(symbolName);
                     }
                 });
             }
         });
-        // Create a final list of methods that are abstract.
-        const methodList = [];
+        // Create a final list of symbols that are abstract.
+        const symbolList = [];
         symbolTable.forEach((method) => {
-            methodList.push(method);
+            symbolList.push(method);
         });
-        return methodList;
+        return symbolList;
     }
     // If the memberType is an instance or class method, creates a new
     // version of the function that has the "self" or "cls" parameter bound
@@ -18553,7 +18632,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     !memberTypeFirstParam.isNameSynthesized &&
                     memberTypeFirstParam.hasDeclaredType) {
                     if (diag) {
-                        diag.addMessage(localize_1.Localizer.Diagnostic.bindTypeMismatch().format({
+                        diag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
                             type: printType(baseType),
                             methodName: memberType.details.name || '<anonymous>',
                             paramName: memberTypeFirstParam.name,
@@ -18821,7 +18900,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypeOfMagicMethodCall,
         bindFunctionToClassOrObject,
         getCallSignatureInfo,
-        getAbstractMethods,
+        getAbstractSymbols,
         narrowConstrainedTypeVar,
         assignType,
         validateOverrideMethod,
@@ -18843,8 +18922,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         isFinalVariable,
         isFinalVariableDeclaration,
         isExplicitTypeAliasDeclaration,
-        addError,
-        addWarning,
         addInformation,
         addUnusedCode,
         addUnreachableCode,