Refactor

Author: Xvezda

src/rules/no-implicit-propagation.js

@@ -11,7 +11,7 @@ const {
   getJSDocThrowsTagTypes,
   getDeclarationTSNodeOfESTreeNode,
   toFlattenedTypeArray,
-  isTypesAssignableTo,
+  groupTypesByCompatibility,
   findClosestFunctionNode,
   findNodeToComment,
   createInsertJSDocBeforeFixer,
@@ -178,29 +178,14 @@ module.exports = createRule({
 
         const callerThrowsTypes = toFlattenedTypeArray(getJSDocThrowsTagTypes(checker, callerDeclarationTSNode));
 
-        if (
-          isTypesAssignableTo(services.program, calleeThrowsTypes, callerThrowsTypes)
-        ) {
+        const typeGroups = groupTypesByCompatibility(services.program, calleeThrowsTypes, callerThrowsTypes);
+        if (!typeGroups.incompatible) {
           return;
         }
 
         const lastThrowsTypeNode = getLast(callerThrowsTypeNodes);
         if (!lastThrowsTypeNode) return;
 
-        const notAssignableThrows = calleeThrowsTypes
-          .filter((calleeType) => !callerThrowsTypes
-            .some((callerType) => {
-              if (
-                utils.isErrorLike(services.program, callerType) &&
-                utils.isErrorLike(services.program, calleeType)
-              ) {
-                return utils.typeIsOrHasBaseType(calleeType, callerType);
-              }
-              return checker.isTypeAssignableTo(calleeType, callerType);
-            }));
-
-        if (!notAssignableThrows.length) return;
-
         context.report({
           node,
           messageId: 'throwTypeMismatch',
@@ -224,11 +209,14 @@ module.exports = createRule({
                   jsdocString
                 );
 
+              if (!typeGroups.incompatible) {
+                return null;
+              }
               return fixer.replaceTextRange(
                 [callerJSDocTSNode.getStart(), callerJSDocTSNode.getEnd()],
                 appendThrowsTags(
                   callerJSDocTSNode.getFullText(),
-                  notAssignableThrows
+                  typeGroups.incompatible,
                 )
               );
             }

src/rules/no-undocumented-throws.js

@@ -13,7 +13,7 @@ const {
   getOptionsFromContext,
   getJSDocThrowsTags,
   getJSDocThrowsTagTypes,
-  isTypesAssignableTo,
+  groupTypesByCompatibility,
   findClosestFunctionNode,
   findNodeToComment,
   findIdentifierDeclaration,
@@ -113,7 +113,12 @@ module.exports = createRule({
           .map(t => node.async ? checker.getAwaitedType(t) : t)
           .filter(t => !!t);
 
-        if (isTypesAssignableTo(services.program, throwTypes, throwsTagTypes)) return;
+        const typeGroups = groupTypesByCompatibility(
+          services.program,
+          throwTypes,
+          throwsTagTypes,
+        );
+        if (!typeGroups.incompatible) return;
 
         const lastTagtypeNode = getLast(throwsTagTypeNodes);
         if (!lastTagtypeNode) return;

src/utils.js

@@ -3,6 +3,26 @@ const { ESLintUtils, AST_NODE_TYPES } = require('@typescript-eslint/utils');
 const utils = require('@typescript-eslint/type-utils');
 const ts = require('typescript');
 
+// Object.groupBy clone
+/**
+ * Groups an array of objects by a specified key or function.
+ * @template T
+ * @template {string} K
+ * @param {T[]} arr - The array to group.
+ * @param {((item: T) => K)} key
+ * @return {Record<K, T[] | undefined>}
+ */
+const groupBy = (arr, key) => {
+  return arr.reduce((acc, item) => {
+    const groupKey = key(item);
+    if (!acc[groupKey]) {
+      acc[groupKey] = [];
+    }
+    acc[groupKey].push(item);
+    return acc;
+  }, /** @type {Record<string, T[]>} */(Object.create(null)));
+};
+
 /**
  * @template {unknown} T
  * @param {Readonly<T[]>} arr
@@ -173,23 +193,25 @@ const toFlattenedTypeArray = (types) =>
  * @param {import('@typescript-eslint/utils').ParserServicesWithTypeInformation['program']} program
  * @param {import('typescript').Type[]} source
  * @param {import('typescript').Type[]} target
- * @returns {boolean}
+ * @returns {{ compatible?: import('typescript').Type[]; incompatible?: import('typescript').Type[] }}
  */
-const isTypesAssignableTo = (program, source, target) => {
+const groupTypesByCompatibility = (program, source, target) => {
   const checker = program.getTypeChecker();
-  return source
-    .every(sourceType =>
-      target
-        .some(targetType => {
-          if (
-            utils.isErrorLike(program, sourceType) &&
-            utils.isErrorLike(program, targetType)
-          ) {
-            return utils.typeIsOrHasBaseType(sourceType, targetType);
-          }
-          return checker.isTypeAssignableTo(sourceType, targetType);
-        })
+
+  return groupBy(source, sourceType => {
+    const isCompatible = target.some(targetType => {
+      if (
+        utils.isErrorLike(program, sourceType) &&
+        utils.isErrorLike(program, targetType)
+      ) {
+        return utils.typeIsOrHasBaseType(sourceType, targetType);
+      }
+      return checker.isTypeAssignableTo(sourceType, targetType);
+    });
+    return /** @type {'compatible'|'incompatible'} */(
+      isCompatible ? 'compatible' : 'incompatible'
     );
+  })
 }
 
 /**
@@ -399,7 +421,7 @@ module.exports = {
   getJSDocThrowsTags,
   getJSDocThrowsTagTypes,
   toFlattenedTypeArray,
-  isTypesAssignableTo,
+  groupTypesByCompatibility,
   findClosestFunctionNode,
   findNodeToComment,
   findIdentifierDeclaration,