catch async defined functions

Author: Hweinstock

plugins/eslint-plugin-aws-toolkits/lib/rules/no-inline-async-foreach.ts

@@ -6,15 +6,38 @@
 import { ESLintUtils, TSESTree } from '@typescript-eslint/utils'
 import { AST_NODE_TYPES } from '@typescript-eslint/types'
 import { Rule } from 'eslint'
+import { RuleContext } from '@typescript-eslint/utils/ts-eslint'
 
 export const errMsg = 'Avoid using async methods with .forEach as it leads to race conditions'
 
-function isAsyncFunction(node: TSESTree.CallExpressionArgument): boolean {
+function isAsyncFunction<T extends string, T2 extends readonly unknown[]>(
+    context: RuleContext<T, T2>,
+    funcNode: TSESTree.CallExpressionArgument
+) {
+    if (funcNode.type === AST_NODE_TYPES.Identifier) {
+        console.log('is identifier')
+        const scope = context.sourceCode.getScope(funcNode)
+        const maybeFNode =
+            scope.variables.find((v) => v.name === funcNode.name)?.defs.find((d) => !!d)?.node ?? undefined
+        console.log(maybeFNode)
+        if (
+            maybeFNode &&
+            (maybeFNode.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+                maybeFNode.type === AST_NODE_TYPES.FunctionExpression ||
+                maybeFNode.type === AST_NODE_TYPES.FunctionDeclaration) &&
+            maybeFNode.async
+        ) {
+            return true
+        }
+        return false
+    }
     return (
-        (node.type === AST_NODE_TYPES.ArrowFunctionExpression || node.type === AST_NODE_TYPES.FunctionExpression) &&
-        node.async
+        (funcNode.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+            funcNode.type === AST_NODE_TYPES.FunctionExpression) &&
+        funcNode.async
     )
 }
+
 export default ESLintUtils.RuleCreator.withoutDocs({
     meta: {
         docs: {
@@ -36,13 +59,14 @@ export default ESLintUtils.RuleCreator.withoutDocs({
                     node.callee.type === AST_NODE_TYPES.MemberExpression &&
                     node.callee.property.type === AST_NODE_TYPES.Identifier &&
                     node.callee.property.name === 'forEach' &&
-                    node.arguments.length >= 1 &&
-                    isAsyncFunction(node.arguments[0])
+                    node.arguments.length >= 1
                 ) {
-                    return context.report({
-                        node: node,
-                        messageId: 'errMsg',
-                    })
+                    if (isAsyncFunction(context, node.arguments[0])) {
+                        return context.report({
+                            node: node,
+                            messageId: 'errMsg',
+                        })
+                    }
                 }
             },
         }

plugins/eslint-plugin-aws-toolkits/test/rules/no-inline-async-foreach.test.ts

@@ -13,12 +13,18 @@ getRuleTester().run('no-inline-async-foreach', rules['no-inline-async-foreach'],
         'list.forEach(asyncFunctionOrNot)',
         'list.forEach(() => console.log(x))',
         'list.forEach(function () {})',
+        'function f(){} \n list.forEach(f)',
+        'const f = function () {} \n list.forEach(f)',
     ],
 
     invalid: [
         { code: 'list.forEach(async (a) => await Promise.resolve(a * a))', errors: [errMsg] },
         { code: 'list.forEach(async (a: any) => console.log(x))', errors: [errMsg] },
         { code: 'list.forEach((a) => a.forEach(async (b) => a * b))', errors: [errMsg] },
         { code: 'list.forEach(async function () {})', errors: [errMsg] },
+        { code: 'async function f(){} \n list.forEach(f)', errors: [errMsg] },
+        { code: 'const f = async () => {} \n list.forEach(f)', errors: [errMsg] },
+        { code: 'const f = async function () {} \n list.forEach(f)', errors: [errMsg] },
+        { code: 'const f = function () {} \n list.forEach(f)', errors: [errMsg] },
     ],
 })