typescript-eslint · JoshuaKGoldberg · Sep 9, 2024 · Sep 3, 2024 · Sep 3, 2024 · Sep 8, 2024
diff --git a/packages/eslint-plugin/docs/rules/no-unsafe-argument.mdx b/packages/eslint-plugin/docs/rules/no-unsafe-argument.mdx
@@ -41,7 +41,7 @@ const tuple1 = ['a', anyTyped, 'b'] as const;
 foo(...tuple1);
 
 const tuple2 = [1] as const;
-foo('a', ...tuple, anyTyped);
+foo('a', ...tuple2, anyTyped);
 
 declare function bar(arg1: string, arg2: number, ...rest: string[]): void;
 const x = [1, 2] as [number, ...number[]];

diff --git a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
@@ -1,5 +1,6 @@
 import type { TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as tsutils from 'ts-api-utils';
 import type * as ts from 'typescript';
 
 import {
@@ -150,11 +151,11 @@ export default createRule<[], MessageIds>({
     },
     messages: {
       unsafeArgument:
-        'Unsafe argument of type `{{sender}}` assigned to a parameter of type `{{receiver}}`.',
+        'Unsafe argument of type {{sender}} assigned to a parameter of type {{receiver}}.',
       unsafeTupleSpread:
-        'Unsafe spread of a tuple type. The argument is of type `{{sender}}` and is assigned to a parameter of type `{{receiver}}`.',
-      unsafeArraySpread: 'Unsafe spread of an `any` array type.',
-      unsafeSpread: 'Unsafe spread of an `any` type.',
+        'Unsafe spread of a tuple type. The argument is {{sender}} and is assigned to a parameter of type {{receiver}}.',
+      unsafeArraySpread: 'Unsafe spread of an {{sender}} array type.',
+      unsafeSpread: 'Unsafe spread of an {{sender}} type.',
     },
     schema: [],
   },
@@ -163,6 +164,33 @@ export default createRule<[], MessageIds>({
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
 
+    function describeType(type: ts.Type): string {
+      if (tsutils.isIntrinsicErrorType(type)) {
+        return 'error typed';
+      }
+
+      return `\`${checker.typeToString(type)}\``;
+    }
+
+    function describeTypeForSpread(type: ts.Type): string {
+      if (
+        checker.isArrayType(type) &&
+        tsutils.isIntrinsicErrorType(checker.getTypeArguments(type)[0])
+      ) {
+        return 'error';
+      }
+
+      return describeType(type);
+    }
+
+    function describeTypeForTuple(type: ts.Type): string {
+      if (tsutils.isIntrinsicErrorType(type)) {
+        return 'error typed';
+      }
+
+      return `of type \`${checker.typeToString(type)}\``;
+    }
+
     function checkUnsafeArguments(
       args: TSESTree.Expression[] | TSESTree.CallExpressionArgument[],
       callee: TSESTree.Expression,
@@ -200,6 +228,7 @@ export default createRule<[], MessageIds>({
             if (isTypeAnyType(spreadArgType)) {
               // foo(...any)
               context.report({
+                data: { sender: describeType(spreadArgType) },
                 node: argument,
                 messageId: 'unsafeSpread',
               });
@@ -208,6 +237,7 @@ export default createRule<[], MessageIds>({
 
               // TODO - we could break down the spread and compare the array type against each argument
               context.report({
+                data: { sender: describeTypeForSpread(spreadArgType) },
                 node: argument,
                 messageId: 'unsafeArraySpread',
               });
@@ -233,8 +263,8 @@ export default createRule<[], MessageIds>({
                     node: argument,
                     messageId: 'unsafeTupleSpread',
                     data: {
-                      sender: checker.typeToString(tupleType),
-                      receiver: checker.typeToString(parameterType),
+                      sender: describeTypeForTuple(tupleType),
+                      receiver: describeType(parameterType),
                     },
                   });
                 }
@@ -270,8 +300,8 @@ export default createRule<[], MessageIds>({
                 node: argument,
                 messageId: 'unsafeArgument',
                 data: {
-                  sender: checker.typeToString(argumentType),
-                  receiver: checker.typeToString(parameterType),
+                  sender: describeType(argumentType),
+                  receiver: describeType(parameterType),
                 },
               });
             }

diff --git a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-unsafe-argument.shot b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-unsafe-argument.shot