fix(eslint-plugin): [require-await] handle async generators

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

@@ -11,6 +11,8 @@ interface ScopeInfo {
   upper: ScopeInfo | null;
   hasAwait: boolean;
   hasAsync: boolean;
+  isGen: boolean;
+  isAsyncYield: boolean;
 }
 type FunctionNode =
   | TSESTree.FunctionDeclaration
@@ -49,9 +51,28 @@ export default util.createRule({
         upper: scopeInfo,
         hasAwait: false,
         hasAsync: node.async,
+        isGen: node.generator || false,
+        isAsyncYield: false,
       };
     }
 
+    /**
+     * Returns `true` if the node is asycn, generator and returnType is Promise
+     */
+    function isValidAsyncGenerator(node: FunctionNode): Boolean {
+      const { async, generator, returnType } = node;
+      if (async && generator && returnType) {
+        if (
+          !!~['Promise'].indexOf(
+            node.returnType?.typeAnnotation?.typeName?.name,
+          )
+        ) {
+          return true;
+        }
+      }
+      return false;
+    }
+
     /**
      * Pop the top scope info object from the stack.
      * Also, it reports the function if needed.
@@ -62,7 +83,13 @@ export default util.createRule({
         return;
       }
 
-      if (node.async && !scopeInfo.hasAwait && !isEmptyFunction(node)) {
+      if (
+        !isValidAsyncGenerator(node) &&
+        node.async &&
+        !scopeInfo.hasAwait &&
+        !isEmptyFunction(node) &&
+        !(scopeInfo.isGen && scopeInfo.isAsyncYield)
+      ) {
         context.report({
           node,
           loc: getFunctionHeadLoc(node, sourceCode),
@@ -92,10 +119,34 @@ export default util.createRule({
       if (!scopeInfo) {
         return;
       }
-
       scopeInfo.hasAwait = true;
     }
 
+    /**
+     * mark `scopeInfo.isAsyncYield` to `true` if its a generator
+     * function and the delegate is `true`
+     */
+    function markAsHasDelegateGen(node: FunctionNode): void {
+      if (!scopeInfo || !scopeInfo.isGen) {
+        return;
+      }
+
+      if (node?.argument?.type === AST_NODE_TYPES.Literal) {
+        // making this `true` as for literals we dont need to check the defination
+        // eg : async function* run() { yield* 1 }
+        scopeInfo.isAsyncYield = true;
+      }
+
+      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node?.argument);
+      const type = checker.getTypeAtLocation(tsNode);
+      const symbol = type.getSymbol();
+
+      // async function* test1() {yield* asyncGenerator() }
+      if (symbol?.getName() === 'AsyncGenerator') {
+        scopeInfo.isAsyncYield = true;
+      }
+    }
+
     return {
       FunctionDeclaration: enterFunction,
       FunctionExpression: enterFunction,
@@ -106,6 +157,7 @@ export default util.createRule({
 
       AwaitExpression: markAsHasAwait,
       'ForOfStatement[await = true]': markAsHasAwait,
+      'YieldExpression[delegate = true]': markAsHasDelegateGen,
 
       // check body-less async arrow function.
       // ignore `async () => await foo` because it's obviously correct