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

package/dist/analyzer/typeEvaluator.js

@@ -2188,7 +2188,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiagAddendum) {
                     diagAddendum = expectedTypeDiagAddendum;
                 }
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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;
@@ -2441,7 +2441,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (!diagAddendum.isEmpty()) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, (target.nodeType === 31 /* ParseNodeType.List */
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, (target.nodeType === 31 /* ParseNodeType.List */
                 ? localize_1.LocMessage.listAssignmentMismatch()
                 : localize_1.LocMessage.tupleAssignmentMismatch()).format({
                 type: printType(type),
@@ -3018,7 +3018,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (effectiveTypeInfo.includesIllegalTypeAliasDecl ||
                                 !types_1.TypeBase.isInstantiable(type) ||
                                 (flags & 2 /* EvaluatorFlags.DoNotSpecialize */) !== 0) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAnnotationVariable(), node);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), node);
                                 type = types_1.UnknownType.create();
                             }
                         }
@@ -3655,7 +3655,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (!type) {
                         if (!isIncomplete) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.moduleUnknownMember().format({
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, localize_1.LocMessage.moduleUnknownMember().format({
                                 memberName,
                                 moduleName: baseType.moduleName,
                             }), node.memberName);
@@ -3741,7 +3741,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 const rule = isFunctionRule
                     ? diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess
-                    : diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues;
+                    : 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
@@ -4732,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsExpectingNone().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                             name: printType(types_1.ClassType.cloneAsInstance(concreteSubtype)),
                         }), node);
                     }
@@ -4800,7 +4800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return concreteSubtype;
                 }
                 if (concreteSubtype.typeArguments) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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;
@@ -4837,7 +4837,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return types_1.UnknownType.create();
             }
             if (!isIncomplete) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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,7 +4968,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const magicMethodName = getIndexAccessMagicMethodName(usage);
         const itemMethodType = getBoundMagicMethod(baseType, magicMethodName, selfType);
         if (!itemMethodType) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodNotDefinedOnType().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.methodNotDefinedOnType().format({
                 name: magicMethodName,
                 type: printType(baseType),
             }), node.baseExpression);
@@ -5324,7 +5324,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // a zero-length tuple.
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useTupleInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.tupleInAnnotation() + diag.getString(), node);
+            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,7 +5493,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             node.leftExpression.value === 'type') {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useTypeInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeCallNotAllowed() + diag.getString(), node);
+            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 */) {
@@ -5593,7 +5593,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAnnotationCall(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationCall(), node);
             typeResult = { type: types_1.UnknownType.create() };
         }
         return typeResult;
@@ -5662,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.assertTypeTypeMismatch().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
                 expected: srcDestTypes.destType,
                 received: srcDestTypes.sourceType,
             }), node.arguments[0].valueExpression);
@@ -5777,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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 {
@@ -5829,7 +5829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 reportError = true;
             }
             if (reportError) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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() };
             }
         }
@@ -6264,7 +6264,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return typeString;
                 });
                 diagAddendum.addMessage(localize_1.LocAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
             }
             return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall: [] };
         }
@@ -6284,7 +6284,7 @@ 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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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.LocAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.uri, overrideDecl.range);
@@ -6415,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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 };
@@ -6495,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.moduleNotCallable(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
                 return { argumentErrors: true };
             }
         }
@@ -6504,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.callableNotInstantiable().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.callableNotInstantiable().format({
                 type: printType(expandedCallType),
             }), errorNode);
             return { returnType: undefined, argumentErrors: true };
@@ -6671,7 +6671,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         if (expandedCallType.literalValue !== undefined) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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)) {
@@ -6679,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.objectNotCallable().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                         type: printType(expandedCallType),
                     }), errorNode);
                     return { returnType: types_1.UnknownType.create(), argumentErrors: true };
@@ -6751,7 +6751,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return { returnType: createNewType(errorNode, argList) };
             }
             if (types_1.ClassType.isSpecialFormClass(expandedCallType)) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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 (className === 'TypedDict') {
@@ -6793,14 +6793,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 });
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.instantiateProtocol().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAbstractUsage, localize_1.LocMessage.instantiateProtocol().format({
                 type: expandedCallType.details.name,
             }), errorNode);
         }
@@ -6848,7 +6848,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* selfType */ undefined, recursionCount);
         const callMethodType = callMethodResult === null || callMethodResult === void 0 ? void 0 : callMethodResult.type;
         if (!callMethodType) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.objectNotCallable().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                 type: printType(expandedCallType),
             }), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
@@ -7049,7 +7049,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argIndex < positionalOnlyLimitIndex && argList[argIndex].name) {
                 const nameNode = argList[argIndex].name;
                 if (nameNode) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.argPositional(), nameNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.argPositional(), nameNode);
                     reportedArgError = true;
                 }
             }
@@ -7083,7 +7083,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (tooManyPositionals) {
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
@@ -7116,7 +7116,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argTypeResult.type.paramSpecAccess === 'args' &&
                         paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
@@ -7183,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
                     }
                     reportedArgError = true;
                 }
@@ -7241,7 +7241,7 @@ 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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, remainingArgCount === 1
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, remainingArgCount === 1
                                     ? localize_1.LocMessage.argMorePositionalExpectedOne()
                                     : localize_1.LocMessage.argMorePositionalExpectedCount().format({
                                         expected: remainingArgCount,
@@ -7323,7 +7323,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (argsRemainingCount > 0) {
                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, argsRemainingCount === 1
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, argsRemainingCount === 1
                         ? localize_1.LocMessage.argMorePositionalExpectedOne()
                         : localize_1.LocMessage.argMorePositionalExpectedCount().format({
                             expected: argsRemainingCount,
@@ -7405,7 +7405,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         });
                         if (!diag.isEmpty()) {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
                             }
                             reportedArgError = true;
                         }
@@ -7466,7 +7466,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                             if (!isValidMappingType) {
                                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
                                 }
                                 reportedArgError = true;
                             }
@@ -7487,7 +7487,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (paramEntry && !paramEntry.isPositionalOnly) {
                             if (paramEntry.argsReceived > 0) {
                                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
                                 }
                                 reportedArgError = true;
                             }
@@ -7531,7 +7531,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         else {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramNameMissing().format({ name: paramName.value }), paramName);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramNameMissing().format({ name: paramName.value }), paramName);
                             }
                             reportedArgError = true;
                         }
@@ -7542,7 +7542,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         else {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                     ? localize_1.LocMessage.argPositionalExpectedOne()
                                     : localize_1.LocMessage.argPositionalExpectedCount().format({
                                         expected: positionParamLimitIndex,
@@ -7619,7 +7619,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!isDiagnosticSuppressedForNode(errorNode)) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, unassignedParams.length === 1
                                 ? localize_1.LocMessage.argMissingForParam().format({ name: missingParamNames })
                                 : localize_1.LocMessage.argMissingForParams().format({ names: missingParamNames }), errorNode);
                         }
@@ -7689,7 +7689,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
                                 !argParam.mapsToVarArgList) {
                                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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;
                             }
@@ -7867,7 +7867,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         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.reportGeneralTypeIssues, localize_1.LocMessage.abstractMethodInvocation().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAbstractUsage, localize_1.LocMessage.abstractMethodInvocation().format({
                     method: type.details.name,
                 }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
             }
@@ -8021,7 +8021,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else if (type.details.paramSpec) {
             if (!sawParamSpecArgs || !sawParamSpecKwargs) {
                 if (!isTypeIncomplete) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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;
@@ -8291,7 +8291,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argumentErrors = true;
             }
             if (argumentErrors) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecArgsMissing().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsMissing().format({
                     type: printType(functionType.details.paramSpec),
                 }), argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : errorNode);
             }
@@ -8356,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
@@ -8484,7 +8485,7 @@ 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 argTypeText = printType(argType);
@@ -8528,7 +8529,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiag) {
                     diag = expectedTypeDiag;
                 }
-                addDiagnostic(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 };
         }
@@ -8966,7 +8967,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         let className = '';
         if (argList.length !== 2) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeParamCount(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.newTypeParamCount(), errorNode);
             return undefined;
         }
         const nameArg = argList[0];
@@ -8976,7 +8977,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             className = nameArg.valueExpression.strings.map((s) => s.value).join('');
         }
         if (!className) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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 */ &&
@@ -9166,7 +9167,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useDictInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dictInAnnotation() + diag.getString(), node);
+            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.
@@ -9489,7 +9490,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useListInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.listInAnnotation() + diag.getString(), node);
+            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.
@@ -10159,6 +10160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     sawUnpacked = true;
                 };
                 typeList.forEach((entry, index) => {
+                    var _a;
                     let entryType = entry.type;
                     let paramCategory = 0 /* ParameterCategory.Simple */;
                     const paramName = `__p${index.toString()}`;
@@ -10170,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 {
@@ -10273,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;
     }
@@ -10434,7 +10438,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         // Self doesn't support any type arguments.
         if (typeArgs) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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);
         }
@@ -10582,7 +10586,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function createFinalType(classType, errorNode, typeArgs, flags) {
         if (flags & 16 /* EvaluatorFlags.DisallowFinal */) {
             addError(localize_1.LocMessage.finalContext(), errorNode);
-            return types_1.AnyType.create();
+            return classType;
         }
         if (!typeArgs || typeArgs.length === 0) {
             return classType;
@@ -10590,7 +10594,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeArgs.length > 1) {
             addError(localize_1.LocMessage.finalTooManyArgs(), errorNode);
         }
-        return typeArgs[0].type;
+        return types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType);
     }
     function createConcatenateType(classType, errorNode, typeArgs, flags) {
         if ((flags & 134217728 /* EvaluatorFlags.AllowConcatenate */) === 0) {
@@ -10662,6 +10666,7 @@ 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) {
@@ -10673,12 +10678,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             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) {
+                            if ((0, types_1.isVariadicTypeVar)(typeArgs[0].type) && !typeArgs[0].type.isVariadicInUnion) {
                                 addError(localize_1.LocMessage.typeVarTupleContext(), typeArgs[0].node);
                             }
-                            else if (sawUnpacked) {
+                            else if ((0, types_1.isUnpackedClass)(typeArgs[0].type)) {
                                 addError(localize_1.LocMessage.ellipsisAfterUnpacked(), typeArg.node);
                             }
                         }
@@ -10686,14 +10689,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     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) {
+                    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 {
@@ -10810,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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;
     }
@@ -11114,7 +11119,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (isDeclaredTypeAlias(node.leftExpression)) {
                     typeAliasNameNode = node.leftExpression.valueExpression;
                     if (!isLegalTypeAliasExpressionForm(node.rightExpression)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
                     }
                 }
                 else if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
@@ -12435,7 +12440,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     if (!assignType(annotatedType, defaultValueType, diagAddendum, typeVarContext)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramAssignmentMismatch().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.paramAssignmentMismatch().format({
                             sourceType: printType(defaultValueType),
                             paramType: printType(annotatedType),
                         }) + diagAddendum.getString(), param.defaultValue);
@@ -13225,7 +13230,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     reportError = true;
                 }
                 if (reportError) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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) {
@@ -13306,7 +13311,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!assignType(declaredType, importedSymbolType, diagAddendum)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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);
@@ -14008,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
                         return { type: types_1.UnknownType.create() };
                     }
                 }
@@ -14051,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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsTooMany().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
                         name: classType.aliasName || classType.details.name,
                         expected: 1,
                         received: typeArgCount,
@@ -14062,12 +14067,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     if (typeParameters.length === 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsTooMany().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
                             name: classType.aliasName || classType.details.name,
                             expected: typeParameters.length,
                             received: typeArgCount,
@@ -14077,7 +14082,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (typeArgCount < minTypeArgCount) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsTooFew().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooFew().format({
                     name: classType.aliasName || classType.details.name,
                     expected: minTypeArgCount,
                     received: typeArgCount,
@@ -14232,7 +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);
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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);