Merge pull request #27 from Xvezda/feature/refactor

Refactor

Author: Xvezda

src/rules/no-implicit-propagation.js

@@ -3,6 +3,7 @@ const { ESLintUtils, AST_NODE_TYPES } = require('@typescript-eslint/utils');
 const utils = require('@typescript-eslint/type-utils');
 const {
   getLast,
+  getNodeID,
   createRule,
   isInHandledContext,
   typesToUnionString,
@@ -11,7 +12,7 @@ const {
   getJSDocThrowsTagTypes,
   getDeclarationTSNodeOfESTreeNode,
   toFlattenedTypeArray,
-  isTypesAssignableTo,
+  groupTypesByCompatibility,
   findClosestFunctionNode,
   findNodeToComment,
   createInsertJSDocBeforeFixer,
@@ -147,8 +148,8 @@ module.exports = createRule({
 
     /** @param {import('@typescript-eslint/utils').TSESTree.Expression} node */
     const visitExpression = (node) => {
-      if (visitedNodes.has(node.range[0])) return;
-      visitedNodes.add(node.range[0]);
+      if (visitedNodes.has(getNodeID(node))) return;
+      visitedNodes.add(getNodeID(node));
 
       if (isInHandledContext(node)) return;
 
@@ -178,29 +179,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 +210,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

@@ -5,6 +5,7 @@ const ts = require('typescript');
 const {
   getFirst,
   getLast,
+  getNodeID,
   createRule,
   findParent,
   hasJSDocThrowsTag,
@@ -13,7 +14,7 @@ const {
   getOptionsFromContext,
   getJSDocThrowsTags,
   getJSDocThrowsTagTypes,
-  isTypesAssignableTo,
+  groupTypesByCompatibility,
   findClosestFunctionNode,
   findNodeToComment,
   findIdentifierDeclaration,
@@ -60,14 +61,6 @@ module.exports = createRule({
 
     const visitedNodes = new Set();
 
-    /**
-     * @param {import('@typescript-eslint/utils').TSESTree.Node} node
-     * @returns {string}
-     */
-    const getNodeID = (node) => {
-      return `${node.type}:${node.loc.start.line}:${node.loc.start.column}`;
-    };
-
     /**
      * Group throw statements in functions
      * @type {Map<string, import('@typescript-eslint/utils').TSESTree.ThrowStatement[]>}
@@ -113,7 +106,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
@@ -32,6 +52,14 @@ const hasThrowsTag = comment =>
   comment.includes('@throws') ||
   comment.includes('@exception');
 
+/**
+ * @param {import('@typescript-eslint/utils').TSESTree.Node} node
+ * @returns {string}
+ */
+const getNodeID = (node) => {
+  return `${node.loc.start.line}:${node.loc.start.column}`;
+};
+
 /**
  * Check if node has JSDoc comment with @throws or @exception tag.
  *
@@ -173,23 +201,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'
     );
+  })
 }
 
 /**
@@ -388,6 +418,7 @@ const createInsertJSDocBeforeFixer = (sourceCode, node, typeString) => {
 module.exports = {
   getFirst,
   getLast,
+  getNodeID,
   createRule,
   hasThrowsTag,
   hasJSDocThrowsTag,
@@ -399,7 +430,7 @@ module.exports = {
   getJSDocThrowsTags,
   getJSDocThrowsTagTypes,
   toFlattenedTypeArray,
-  isTypesAssignableTo,
+  groupTypesByCompatibility,
   findClosestFunctionNode,
   findNodeToComment,
   findIdentifierDeclaration,