Merge pull request #9 from Xvezda/feature/fix-bugs

feature/fix bugs

Author: Xvezda

examples/fixed.js

@@ -27,3 +27,23 @@ class Fizz {
   }
 }
 new Fizz().buzz();
+
+const egg = {
+  get ham() {
+    return {
+      /**
+       * @throws {Error}
+       */
+      get spam() {
+        throw new Error();
+      },
+    };
+  }
+};
+
+const lol = () => {
+  try {
+    console.log(egg.ham.spam);
+  } catch {}
+};
+lol();

examples/unsafe.js

@@ -18,3 +18,18 @@ class Fizz {
   }
 }
 new Fizz().buzz();
+
+const egg = {
+  get ham() {
+    return {
+      get spam() {
+        throw new Error();
+      },
+    };
+  }
+};
+
+const lol = () => {
+  console.log(egg.ham.spam);
+};
+lol();

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 {
   createRule,
+  findClosest,
   hasThrowsTag,
   getOptionsFromContext,
   getCalleeDeclaration,
@@ -164,25 +165,32 @@ module.exports = createRule({
       // TODO: Better way to handle this?
       if (/^\s*try\s*\{/.test(prevLine)) return;
 
+      const nodeToWrap = findClosest(node, (n) =>
+        n.type === AST_NODE_TYPES.BlockStatement ||
+        n.type === AST_NODE_TYPES.ExpressionStatement ||
+        n.type === AST_NODE_TYPES.VariableDeclaration
+      );
+      if (!nodeToWrap) return;
+
       context.report({
         node,
         messageId: 'implicitPropagation',
         fix(fixer) {
           return [
-            fixer.insertTextBefore(node, `try {\n${newIndent}`),
-            fixer.insertTextAfter(node, `\n${indent}} catch {}`),
+            fixer.insertTextBefore(nodeToWrap, `try {\n${newIndent}`),
+            fixer.insertTextAfter(nodeToWrap, `\n${indent}} catch {}`),
           ];
         },
       });
     };
 
     return {
-      'ArrowFunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement:has(> CallExpression)': visitExpressionStatement,
-      'FunctionDeclaration :not(TryStatement[handler!=null]) ExpressionStatement:has(> CallExpression)': visitExpressionStatement,
-      'FunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement:has(> CallExpression)': visitExpressionStatement,
-      'ArrowFunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement:has(> MemberExpression)': visitExpressionStatement,
-      'FunctionDeclaration :not(TryStatement[handler!=null]) ExpressionStatement:has(> MemberExpression)': visitExpressionStatement,
-      'FunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement:has(> MemberExpression)': visitExpressionStatement,
+      'ArrowFunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement MemberExpression[property.type="Identifier"]': visitExpressionStatement,
+      'FunctionDeclaration :not(TryStatement[handler!=null]) ExpressionStatement MemberExpression[property.type="Identifier"]': visitExpressionStatement,
+      'FunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement MemberExpression[property.type="Identifier"]': visitExpressionStatement,
+      'ArrowFunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement CallExpression[callee.type="Identifier"]': visitExpressionStatement,
+      'FunctionDeclaration :not(TryStatement[handler!=null]) ExpressionStatement CallExpression[callee.type="Identifier"]': visitExpressionStatement,
+      'FunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement CallExpression[callee.type="Identifier"]': visitExpressionStatement,
       'ArrowFunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement:has(> AssignmentExpression[left.type="MemberExpression"])': visitExpressionStatement,
       'FunctionDeclaration :not(TryStatement[handler!=null]) ExpressionStatement:has(> AssignmentExpression[left.type="MemberExpression"])': visitExpressionStatement,
       'FunctionExpression :not(TryStatement[handler!=null]) ExpressionStatement:has(> AssignmentExpression[left.type="MemberExpression"])': visitExpressionStatement,

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

@@ -790,7 +790,56 @@ ruleTester.run(
           },
         ],
       },
+      {
+        code: `
+          const egg = {
+            get ham() {
+              return {
+                /**
+                 * @throws {Error}
+                 */
+                get spam() {
+                  throw new Error();
+                },
+              };
+            }
+          };
+
+          const lol = () => {
+            console.log(egg.ham.spam);
+          };
+          lol();
+        `,
+        output: `
+          const egg = {
+            get ham() {
+              return {
+                /**
+                 * @throws {Error}
+                 */
+                get spam() {
+                  throw new Error();
+                },
+              };
+            }
+          };
+
+          const lol = () => {
+            try {
+              console.log(egg.ham.spam);
+            } catch {}
+          };
+          lol();
+        `,
+        errors: [
+          { messageId: 'implicitPropagation' },
+        ],
+        options: [
+          {
+            tabLength: 2,
+          },
+        ],
+      },
     ],
   },
 );
-

src/utils.js

@@ -66,17 +66,17 @@ const getDeclarationsByNode = (services, node) => {
 };
 
 /**
- * @param {import('@typescript-eslint/utils').TSESTree.ExpressionStatement} node
+ * @param {import('@typescript-eslint/utils').TSESTree.Node} node
  * @return {import('@typescript-eslint/utils').TSESTree.Node | null}
  */
 const getCalleeFromExpression = (node) => {
-  switch (node.expression.type) {
+  switch (node.type) {
+    case AST_NODE_TYPES.MemberExpression:
+      return node.property;
     case AST_NODE_TYPES.CallExpression:
-      return node.expression.callee;
+      return node.callee;
     case AST_NODE_TYPES.AssignmentExpression:
-      return node.expression.left;
-    case AST_NODE_TYPES.MemberExpression:
-      return node.expression.property;
+      return node.left;
     default:
       break;
   }
@@ -96,16 +96,18 @@ const getCalleeDeclaration = (services, node) => {
     return null;
   }
 
-  switch (node.expression.type) {
-    case AST_NODE_TYPES.CallExpression:
-      return declarations[0];
+  switch (node.type) {
     case AST_NODE_TYPES.MemberExpression:
       const getter = declarations
         .find(declaration =>
           services.tsNodeToESTreeNodeMap
-            .get(declaration).kind === 'get'
+            .get(declaration)?.kind === 'get'
         );
-      return getter ?? declarations[0];
+      if (getter) {
+        return getter;
+      }
+    case AST_NODE_TYPES.CallExpression:
+      return declarations[0];
     case AST_NODE_TYPES.AssignmentExpression:
       const setter = declarations
         .find(declaration =>