fix(eslint-plugin): [return-await] don't error for in-try-catch if the return is in a catch without a finally

packages/eslint-plugin/src/rules/return-await.ts

@@ -57,23 +57,63 @@ export default util.createRule({
       };
     }
 
-    function inTryCatch(node: ts.Node): boolean {
+    function inTry(node: ts.Node): boolean {
+      let ancestor = node.parent;
+
+      while (ancestor && !ts.isFunctionLike(ancestor)) {
+        if (tsutils.isTryStatement(ancestor)) {
+          return true;
+        }
+
+        ancestor = ancestor.parent;
+      }
+
+      return false;
+    }
+
+    function inCatch(node: ts.Node): boolean {
+      let ancestor = node.parent;
+
+      while (ancestor && !ts.isFunctionLike(ancestor)) {
+        if (tsutils.isCatchClause(ancestor)) {
+          return true;
+        }
+
+        ancestor = ancestor.parent;
+      }
+
+      return false;
+    }
+
+    function isReturnPromiseInFinally(node: ts.Node): boolean {
       let ancestor = node.parent;
 
       while (ancestor && !ts.isFunctionLike(ancestor)) {
         if (
-          tsutils.isTryStatement(ancestor) ||
-          tsutils.isCatchClause(ancestor)
+          tsutils.isTryStatement(ancestor.parent) &&
+          tsutils.isBlock(ancestor) &&
+          ancestor.parent.end === ancestor.end
         ) {
           return true;
         }
-
         ancestor = ancestor.parent;
       }
 
       return false;
     }
 
+    function hasFinallyBlock(node: ts.Node): boolean {
+      let ancestor = node.parent;
+
+      while (ancestor && !ts.isFunctionLike(ancestor)) {
+        if (tsutils.isTryStatement(ancestor)) {
+          return !!ancestor.finallyBlock;
+        }
+        ancestor = ancestor.parent;
+      }
+      return false;
+    }
+
     // function findTokensToRemove()
 
     function removeAwait(
@@ -163,14 +203,22 @@ export default util.createRule({
       }
 
       if (option === 'in-try-catch') {
-        const isInTryCatch = inTryCatch(expression);
+        const isInTryCatch = inTry(expression) || inCatch(expression);
         if (isAwait && !isInTryCatch) {
           context.report({
             messageId: 'disallowedPromiseAwait',
             node,
             fix: fixer => removeAwait(fixer, node),
           });
         } else if (!isAwait && isInTryCatch) {
+          if (inCatch(expression) && !hasFinallyBlock(expression)) {
+            return;
+          }
+
+          if (isReturnPromiseInFinally(expression)) {
+            return;
+          }
+
           context.report({
             messageId: 'requiredPromiseAwait',
             node,

packages/eslint-plugin/tests/rules/return-await.test.ts

@@ -112,6 +112,32 @@ ruleTester.run('return-await', rule, {
         }
       `,
     },
+    {
+      options: ['in-try-catch'],
+      code: `
+        async function test() {
+          try {
+            throw 'foo';
+          } catch (e) {
+            return Promise.resolve(1);
+          }
+        }
+      `,
+    },
+    {
+      options: ['in-try-catch'],
+      code: `
+        async function test() {
+          try {
+            throw 'foo';
+          } catch (e) {
+            throw 'foo2';
+          } finally {
+            return Promise.resolve(1);
+          }
+        }
+      `,
+    },
     {
       options: ['in-try-catch'],
       code: `