Fix: handle try/catch correctly in no-return-await (fixes #7581) (#…

…7582)

* Fix: handle try/catch correctly in `no-return-await` (fixes #7581)

* Use a while loop instead of recursion

lib/rules/no-return-await.js

@@ -4,6 +4,8 @@
  */
 "use strict";
 
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -23,6 +25,26 @@ module.exports = {
     },
 
     create(context) {
+
+        /**
+        * Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting
+        * this function. For example, a statement in a `try` block will always have an error handler. A statement in
+        * a `catch` block will only have an error handler if there is also a `finally` block.
+        * @param {ASTNode} node A node representing a location where an could be thrown
+        * @returns {boolean} `true` if a thrown error will be caught/handled in this function
+        */
+        function hasErrorHandler(node) {
+            let ancestor = node;
+
+            while (!astUtils.isFunction(ancestor) && ancestor.type !== "Program") {
+                if (ancestor.parent.type === "TryStatement" && (ancestor === ancestor.parent.block || ancestor === ancestor.parent.handler && ancestor.parent.finalizer)) {
+                    return true;
+                }
+                ancestor = ancestor.parent;
+            }
+            return false;
+        }
+
         return {
             ArrowFunctionExpression(node) {
                 if (node.async && node.body.type === "AwaitExpression") {
@@ -39,7 +61,7 @@ module.exports = {
             ReturnStatement(node) {
                 const argument = node.argument;
 
-                if (argument && argument.type === "AwaitExpression") {
+                if (argument && argument.type === "AwaitExpression" && !hasErrorHandler(node)) {
                     const sourceCode = context.getSourceCode();
                     const loc = argument.loc;
 

tests/lib/rules/no-return-await.js

@@ -16,54 +16,148 @@ const RuleTester = require("../../../lib/testers/rule-tester");
 // Tests
 //------------------------------------------------------------------------------
 
+// pending https://github.com/eslint/espree/issues/304, the type should be "Keyword"
+const errors = [{ message: "Redundant use of `await` on a return value.", type: "Identifier"}];
+
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 2017 } });
 
 ruleTester.run("no-return-await", rule, {
 
     valid: [
-        { code: "\nasync function foo() {\n\tawait bar(); return;\n}\n" },
-        { code: "\nasync function foo() {\n\tconst x = await bar(); return x;\n}\n" },
-        { code: "\nasync () => { return bar(); }\n" },
-        { code: "\nasync () => bar()\n" },
-        { code: "\nasync function foo() {\nif (a) {\n\t\tif (b) {\n\t\t\treturn bar();\n\t\t}\n\t}\n}\n" },
-        { code: "\nasync () => {\nif (a) {\n\t\tif (b) {\n\t\t\treturn bar();\n\t\t}\n\t}\n}\n" },
+        "\nasync function foo() {\n\tawait bar(); return;\n}\n",
+        "\nasync function foo() {\n\tconst x = await bar(); return x;\n}\n",
+        "\nasync () => { return bar(); }\n",
+        "\nasync () => bar()\n",
+        "\nasync function foo() {\nif (a) {\n\t\tif (b) {\n\t\t\treturn bar();\n\t\t}\n\t}\n}\n",
+        "\nasync () => {\nif (a) {\n\t\tif (b) {\n\t\t\treturn bar();\n\t\t}\n\t}\n}\n",
+        `
+          async function foo() {
+            try {
+              return await bar();
+            } catch (e) {
+              baz();
+            }
+          }
+        `,
+        `
+          async function foo() {
+            try {
+              return await bar();
+            } finally {
+              baz();
+            }
+          }
+        `,
+        `
+          async function foo() {
+            try {}
+            catch (e) {
+              return await bar();
+            } finally {
+              baz();
+            }
+          }
+        `,
+        `
+          async function foo() {
+            try {
+              try {}
+              finally {
+                return await bar();
+              }
+            } finally {
+              baz();
+            }
+          }
+        `,
+        `
+          async function foo() {
+            try {
+              try {}
+              catch (e) {
+                return await bar();
+              }
+            } finally {
+              baz();
+            }
+          }
+        `
     ],
 
     invalid: [
         {
             code: "\nasync function foo() {\n\treturn await bar();\n}\n",
-            errors: [{
-                message: "Redundant use of `await` on a return value.",
-                type: "Identifier", // pending https://github.com/eslint/espree/issues/304, should be "Keyword"
-            }],
+            errors,
         },
         {
             code: "\nasync () => { return await bar(); }\n",
-            errors: [{
-                message: "Redundant use of `await` on a return value.",
-                type: "Identifier", // pending https://github.com/eslint/espree/issues/304, should be "Keyword"
-            }],
+            errors,
         },
         {
             code: "\nasync () => await bar()\n",
-            errors: [{
-                message: "Redundant use of `await` on a return value.",
-                type: "Identifier", // pending https://github.com/eslint/espree/issues/304, should be "Keyword"
-            }],
+            errors,
         },
         {
             code: "\nasync function foo() {\nif (a) {\n\t\tif (b) {\n\t\t\treturn await bar();\n\t\t}\n\t}\n}\n",
-            errors: [{
-                message: "Redundant use of `await` on a return value.",
-                type: "Identifier", // pending https://github.com/eslint/espree/issues/304, should be "Keyword"
-            }],
+            errors,
         },
         {
             code: "\nasync () => {\nif (a) {\n\t\tif (b) {\n\t\t\treturn await bar();\n\t\t}\n\t}\n}\n",
-            errors: [{
-                message: "Redundant use of `await` on a return value.",
-                type: "Identifier", // pending https://github.com/eslint/espree/issues/304, should be "Keyword"
-            }],
+            errors,
+        },
+        {
+            code: `
+              async function foo() {
+                try {}
+                finally {
+                  return await bar();
+                }
+              }
+            `,
+            errors
+        },
+        {
+            code: `
+              async function foo() {
+                try {}
+                catch (e) {
+                  return await bar();
+                }
+              }
+            `,
+            errors
         },
+        {
+            code: `
+              try {
+                async function foo() {
+                  return await bar();
+                }
+              } catch (e) {}
+            `,
+            errors
+        },
+        {
+            code: `
+              try {
+                async () => await bar();
+              } catch (e) {}
+            `,
+            errors
+        },
+        {
+            code: `
+              async function foo() {
+                try {}
+                catch (e) {
+                  try {}
+                  catch (e) {
+                    return await bar();
+                  }
+                }
+              }
+            `,
+            errors
+        }
     ]
 });