Merge pull request #25 from Xvezda/feature/update-examples

feature/update examples

Author: Xvezda

examples/fixed.js

@@ -1,20 +1,26 @@
 /**
- * @throws {Error}
+ * @throws {RangeError}
  */
 function foo() {
-  throw new Error();
+  throw new RangeError();
 }
 
+/**
+ * @throws {TypeError}
+ */
 function bar() {
-  try {
-    foo();
-  } catch {}
+  throw new TypeError();
 }
-bar();
 
-/** @throws {Error} */
+/**
+ * @throws {RangeError | TypeError}
+ */
 function baz() {
-  foo();
+  if (Math.random() > 0.5) {
+    foo();
+  } else {
+    bar();
+  }
 }
 baz();
 
@@ -41,10 +47,11 @@ const egg = {
   }
 };
 
+/**
+ * @throws {Error}
+ */
 const lol = () => {
-  try {
-    console.log(egg.ham.spam);
-  } catch {}
+  console.log(egg.ham.spam);
 };
 lol();
 

examples/unsafe.js

@@ -1,14 +1,17 @@
 function foo() {
-  throw new Error();
+  throw new RangeError();
 }
 
 function bar() {
-  foo();
+  throw new TypeError();
 }
-bar();
 
 function baz() {
-  foo();
+  if (Math.random() > 0.5) {
+    foo();
+  } else {
+    bar();
+  }
 }
 baz();
 

src/rules/no-implicit-propagation.js

@@ -161,10 +161,10 @@ module.exports = createRule({
       const calleeDeclaration = getCalleeDeclaration(services, node);
       if (!calleeDeclaration) return;
 
-      if (hasJSDocThrowsTag(sourceCode, nodeToComment)) {
-        const calleeThrowsTypes = toFlattenedTypeArray(getJSDocThrowsTagTypes(checker, calleeDeclaration));
-        if (!calleeThrowsTypes.length) return;
+      const calleeThrowsTypes = toFlattenedTypeArray(getJSDocThrowsTagTypes(checker, calleeDeclaration));
+      if (!calleeThrowsTypes.length) return;
 
+      if (hasJSDocThrowsTag(sourceCode, nodeToComment)) {
         const callerDeclarationTSNode =
           getDeclarationTSNodeOfESTreeNode(services, callerDeclaration);
 
@@ -176,10 +176,10 @@ module.exports = createRule({
             .map(tag => tag.typeExpression?.type)
             .filter(tag => !!tag);
 
-        const callerThrowsTypes = getJSDocThrowsTagTypes(checker, callerDeclarationTSNode);
+        const callerThrowsTypes = toFlattenedTypeArray(getJSDocThrowsTagTypes(checker, callerDeclarationTSNode));
 
         if (
-          isTypesAssignableTo(checker, calleeThrowsTypes, callerThrowsTypes)
+          isTypesAssignableTo(services.program, calleeThrowsTypes, callerThrowsTypes)
         ) {
           return;
         }
@@ -188,8 +188,16 @@ module.exports = createRule({
         if (!lastThrowsTypeNode) return;
 
         const notAssignableThrows = calleeThrowsTypes
-          .filter((t) => !callerThrowsTypes
-            .some((n) => checker.isTypeAssignableTo(t, n)));
+          .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;
 
@@ -228,21 +236,14 @@ module.exports = createRule({
             // If there is only one throws tag, make it as a union type
             return fixer.replaceTextRange(
               [lastThrowsTypeNode.pos, lastThrowsTypeNode.end],
-              calleeThrowsTypes
-                .map(t => utils.getTypeName(checker, t)).join(' | '),
+              typesToUnionString(checker, [...callerThrowsTypes, ...calleeThrowsTypes])
             );
           },
         });
 
         return;
       }
 
-      const calleeTags = getJSDocThrowsTags(calleeDeclaration);
-
-      const isCalleeThrows = calleeTags.length > 0;
-      if (!isCalleeThrows) return;
-      
-      const calleeThrowsTypes = getJSDocThrowsTagTypes(checker, calleeDeclaration);
       context.report({
         node,
         messageId: 'implicitPropagation',

src/rules/no-implicit-propagation.test.js

@@ -315,6 +315,35 @@ ruleTester.run(
           }
         `,
       },
+      {
+        code: `
+          /**
+           * @throws {TypeError}
+           */
+          function foo() {
+            throw new TypeError();
+          }
+
+          /**
+           * @throws {RangeError}
+           */
+          function bar() {
+            throw new RangeError();
+          }
+
+          /**
+           * @throws {Error}
+           */
+          function baz() {
+            if (Math.random() > 0.5) {
+              foo();
+            } else {
+              bar();
+            }
+          }
+          baz();
+        `,
+      },
     ],
     invalid: [
       {
@@ -900,6 +929,65 @@ ruleTester.run(
           { messageId: 'implicitPropagation' },
         ],
       },
+      {
+        code: `
+          /**
+           * @throws {TypeError}
+           */
+          function foo() {
+            throw new TypeError();
+          }
+
+          /**
+           * @throws {RangeError}
+           */
+          function bar() {
+            throw new RangeError();
+          }
+
+          /**
+           * @throws {TypeError}
+           */
+          function baz() {
+            if (Math.random() > 0.5) {
+              foo();
+            } else {
+              bar();
+            }
+          }
+          baz();
+        `,
+        output: `
+          /**
+           * @throws {TypeError}
+           */
+          function foo() {
+            throw new TypeError();
+          }
+
+          /**
+           * @throws {RangeError}
+           */
+          function bar() {
+            throw new RangeError();
+          }
+
+          /**
+           * @throws {TypeError | RangeError}
+           */
+          function baz() {
+            if (Math.random() > 0.5) {
+              foo();
+            } else {
+              bar();
+            }
+          }
+          baz();
+        `,
+        errors: [
+          { messageId: 'throwTypeMismatch' },
+        ],
+      },
     ],
   },
 );

src/rules/no-undocumented-throws.js

@@ -113,7 +113,7 @@ module.exports = createRule({
           .map(t => node.async ? checker.getAwaitedType(t) : t)
           .filter(t => !!t);
 
-        if (isTypesAssignableTo(checker, throwTypes, throwsTagTypes)) return;
+        if (isTypesAssignableTo(services.program, throwTypes, throwsTagTypes)) return;
 
         const lastTagtypeNode = getLast(throwsTagTypeNodes);
         if (!lastTagtypeNode) return;

src/utils.js

@@ -170,17 +170,27 @@ const toFlattenedTypeArray = (types) =>
   types.flatMap(type => type.isUnion() ? type.types : type);
 
 /**
- * @param {import('typescript').TypeChecker} checker
+ * @param {import('@typescript-eslint/utils').ParserServicesWithTypeInformation['program']} program
  * @param {import('typescript').Type[]} source
  * @param {import('typescript').Type[]} target
  * @returns {boolean}
  */
-const isTypesAssignableTo = (checker, source, target) =>
-  source
+const isTypesAssignableTo = (program, source, target) => {
+  const checker = program.getTypeChecker();
+  return source
     .every(sourceType =>
       target
-        .some(targetType => checker.isTypeAssignableTo(sourceType, targetType))
+        .some(targetType => {
+          if (
+            utils.isErrorLike(program, sourceType) &&
+            utils.isErrorLike(program, targetType)
+          ) {
+            return utils.typeIsOrHasBaseType(sourceType, targetType);
+          }
+          return checker.isTypeAssignableTo(sourceType, targetType);
+        })
     );
+}
 
 /**
  * Find closest function where exception is thrown