fix(eslint-plugin): replace unclear "error typed" with more helpful description (#11704)

Author: wjhsf

packages/eslint-plugin/src/rules/no-unsafe-call.ts

@@ -12,6 +12,10 @@ import {
 } from '../util';
 
 export type MessageIds =
+  | 'errorCall'
+  | 'errorCallThis'
+  | 'errorNew'
+  | 'errorTemplateTag'
   | 'unsafeCall'
   | 'unsafeCallThis'
   | 'unsafeNew'
@@ -27,13 +31,18 @@ export default createRule<[], MessageIds>({
       requiresTypeChecking: true,
     },
     messages: {
-      unsafeCall: 'Unsafe call of a(n) {{type}} typed value.',
+      errorCall: 'Unsafe call of a type that could not be resolved.',
+      errorCallThis: 'Unsafe call of a `this` type that could not be resolved.',
+      errorNew: 'Unsafe construction of a type that could not be resolved.',
+      errorTemplateTag:
+        'Unsafe use of a template tag whose type could not be resolved.',
+      unsafeCall: 'Unsafe call of {{type}} typed value.',
       unsafeCallThis: [
-        'Unsafe call of a(n) {{type}} typed value. `this` is typed as {{type}}.',
+        'Unsafe call of {{type}} typed value. `this` is typed as {{type}}.',
         'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
       ].join('\n'),
-      unsafeNew: 'Unsafe construction of a(n) {{type}} typed value.',
-      unsafeTemplateTag: 'Unsafe use of a(n) {{type}} typed template tag.',
+      unsafeNew: 'Unsafe construction of {{type}} typed value.',
+      unsafeTemplateTag: 'Unsafe use of {{type}} typed template tag.',
     },
     schema: [],
   },
@@ -49,7 +58,8 @@ export default createRule<[], MessageIds>({
     function checkCall(
       node: TSESTree.Node,
       reportingNode: TSESTree.Node,
-      messageId: MessageIds,
+      unsafeMessageId: Extract<MessageIds, `unsafe${string}`>,
+      errorMessageId: Extract<MessageIds, `error${string}`>,
     ): void {
       const type = getConstrainedTypeAtLocation(services, node);
 
@@ -63,17 +73,18 @@ export default createRule<[], MessageIds>({
               getConstrainedTypeAtLocation(services, thisExpression),
             )
           ) {
-            messageId = 'unsafeCallThis';
+            unsafeMessageId = 'unsafeCallThis';
+            errorMessageId = 'errorCallThis';
           }
         }
 
         const isErrorType = tsutils.isIntrinsicErrorType(type);
 
         context.report({
           node: reportingNode,
-          messageId,
+          messageId: isErrorType ? errorMessageId : unsafeMessageId,
           data: {
-            type: isErrorType ? '`error` type' : '`any`',
+            type: 'an `any`',
           },
         });
         return;
@@ -98,7 +109,7 @@ export default createRule<[], MessageIds>({
         }
 
         const callSignatures = type.getCallSignatures();
-        if (messageId === 'unsafeNew') {
+        if (unsafeMessageId === 'unsafeNew') {
           if (
             callSignatures.some(
               signature =>
@@ -113,9 +124,9 @@ export default createRule<[], MessageIds>({
 
         context.report({
           node: reportingNode,
-          messageId,
+          messageId: unsafeMessageId,
           data: {
-            type: '`Function`',
+            type: 'a `Function`',
           },
         });
         return;
@@ -126,13 +137,13 @@ export default createRule<[], MessageIds>({
       'CallExpression > *.callee'(
         node: TSESTree.CallExpression['callee'],
       ): void {
-        checkCall(node, node, 'unsafeCall');
+        checkCall(node, node, 'unsafeCall', 'errorCall');
       },
       NewExpression(node): void {
-        checkCall(node.callee, node, 'unsafeNew');
+        checkCall(node.callee, node, 'unsafeNew', 'errorNew');
       },
       'TaggedTemplateExpression > *.tag'(node: TSESTree.Node): void {
-        checkCall(node, node, 'unsafeTemplateTag');
+        checkCall(node, node, 'unsafeTemplateTag', 'errorTemplateTag');
       },
     };
   },

packages/eslint-plugin/src/rules/no-unsafe-member-access.ts

@@ -1,5 +1,4 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import type * as ts from 'typescript';
 
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
@@ -18,18 +17,16 @@ const enum State {
   Chained = 3,
 }
 
-function createDataType(type: ts.Type): '`any`' | '`error` typed' {
-  const isErrorType = tsutils.isIntrinsicErrorType(type);
-  return isErrorType ? '`error` typed' : '`any`';
-}
-
 export type Options = [
   {
     allowOptionalChaining?: boolean;
   },
 ];
 
 export type MessageIds =
+  | 'errorComputedMemberAccess'
+  | 'errorMemberExpression'
+  | 'errorThisMemberExpression'
   | 'unsafeComputedMemberAccess'
   | 'unsafeMemberExpression'
   | 'unsafeThisMemberExpression';
@@ -44,10 +41,18 @@ export default createRule<Options, MessageIds>({
       requiresTypeChecking: true,
     },
     messages: {
+      errorComputedMemberAccess:
+        'The type of computed name {{property}} cannot be resolved.',
+      errorMemberExpression:
+        'Unsafe member access {{property}} on a type that cannot be resolved.',
+      errorThisMemberExpression: [
+        'Unsafe member access {{property}}. The type of `this` cannot be resolved.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
       unsafeComputedMemberAccess:
-        'Computed name {{property}} resolves to an {{type}} value.',
+        'Computed name {{property}} resolves to an `any` value.',
       unsafeMemberExpression:
-        'Unsafe member access {{property}} on an {{type}} value.',
+        'Unsafe member access {{property}} on an `any` value.',
       unsafeThisMemberExpression: [
         'Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.',
         'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
@@ -118,27 +123,34 @@ export default createRule<Options, MessageIds>({
       if (state === State.Unsafe) {
         const propertyName = context.sourceCode.getText(node.property);
 
-        let messageId: MessageIds = 'unsafeMemberExpression';
+        let messageId: MessageIds | undefined;
 
         if (!isNoImplicitThis) {
           // `this.foo` or `this.foo[bar]`
           const thisExpression = getThisExpression(node);
-
-          if (
-            thisExpression &&
-            isTypeAnyType(
-              getConstrainedTypeAtLocation(services, thisExpression),
-            )
-          ) {
-            messageId = 'unsafeThisMemberExpression';
+          if (thisExpression) {
+            const thisType = getConstrainedTypeAtLocation(
+              services,
+              thisExpression,
+            );
+            if (isTypeAnyType(thisType)) {
+              messageId = tsutils.isIntrinsicErrorType(thisType)
+                ? 'errorThisMemberExpression'
+                : 'unsafeThisMemberExpression';
+            }
           }
         }
 
+        if (!messageId) {
+          messageId = tsutils.isIntrinsicErrorType(type)
+            ? 'errorMemberExpression'
+            : 'unsafeMemberExpression';
+        }
+
         context.report({
           node: node.property,
           messageId,
           data: {
-            type: createDataType(type),
             property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
           },
         });
@@ -179,9 +191,10 @@ export default createRule<Options, MessageIds>({
           const propertyName = context.sourceCode.getText(node);
           context.report({
             node,
-            messageId: 'unsafeComputedMemberAccess',
+            messageId: tsutils.isIntrinsicErrorType(type)
+              ? 'errorComputedMemberAccess'
+              : 'unsafeComputedMemberAccess',
             data: {
-              type: createDataType(type),
               property: `[${propertyName}]`,
             },
           });