fix: Handle non-awaited async generator (#4417)

Author: 2767mr

internal/runtime/runtime.go

@@ -418,15 +418,23 @@ func Source(unsupportedJSFeatures compat.JSFeature) logger.Source {
 			var resume = (k, v, yes, no) => {
 				try {
 					var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done
-					Promise.resolve(isAwait ? v[0] : v)
+					return q = Promise.resolve(isAwait ? v[0] : v)
 						.then(y => isAwait
 							? resume(k === 'return' ? k : 'next', v[1] ? { done: y.done, value: y.value } : y, yes, no)
 							: yes({ value: y, done }))
 						.catch(e => resume('throw', e, yes, no))
 				} catch (e) {
+					q = Promise.resolve()
 					no(e)
 				}
-			}, method = k => it[k] = x => new Promise((yes, no) => resume(k, x, yes, no)), it = {}
+			}, method = (k, call, wait, clear) => it[k] = x => (
+				call = new Promise((yes, no, run) => (
+					run = () => resume(k, x, yes, no), 
+					queue ? queue.then(run) : run())),
+				clear = () => queue === wait && (queue = void 0),
+				queue = wait = call.then(clear, clear),
+				call
+			), q, queue, it = {}
 			return generator = generator.apply(__this, __arguments),
 				it[__knownSymbol('asyncIterator')] = () => it,
 				method('next'),

scripts/end-to-end-tests.js

@@ -748,6 +748,127 @@ for (const flags of [[], ['--target=es6', '--target=es2017', '--supported:async-
         }
       `,
     }, { async: true }),
+    test(['in.js', '--outfile=node.js', '--format=esm'].concat(flags), {
+      'in.js': `
+        async function* i() {
+          yield 1
+          yield 2
+        }
+        async function* f() {
+          yield* i()
+        }
+        export let async = async () => {
+          let it, stateA, stateB
+          it = f()
+          stateA = it.next()
+          stateB = it.next()
+
+          stateA = await stateA
+          stateB = await stateB
+
+          if (stateA.done !== false || stateA.value !== 1) throw 'fail: f: next A'
+          if (stateB.done !== false || stateB.value !== 2) throw 'fail: f: next B'
+
+          stateA = await it.next()
+          if (stateA.done !== true || stateA.value !== void 0) throw 'fail: f: done'
+        }
+      `,
+    }, { async: true }),
+    test(['in.js', '--outfile=node.js', '--format=esm'].concat(flags), {
+      'in.js': `
+        async function* i() {
+          yield 1
+          yield 2
+        }
+        async function* f() {
+          for await (const x of i())
+            yield x;
+        }
+        export let async = async () => {
+          let it, stateA, stateB
+          it = f()
+          stateA = it.next()
+          stateB = it.next()
+
+          stateA = await stateA
+          stateB = await stateB
+
+          if (stateA.done !== false || stateA.value !== 1) throw 'fail: f: next A'
+          if (stateB.done !== false || stateB.value !== 2) throw 'fail: f: next B'
+
+          stateA = await it.next()
+          if (stateA.done !== true || stateA.value !== void 0) throw 'fail: f: done'
+        }
+      `,
+    }, { async: true }),
+    test(['in.js', '--outfile=node.js', '--format=esm'].concat(flags), {
+      'in.js': `
+        async function* f() {
+          await Promise.resolve()
+          return yield 1
+        }
+        export let async = async () => {
+          let it, stateA, stateB
+          it = f()
+          stateA = it.next()
+          stateB = it.next(2)
+
+          stateA = await stateA
+          stateB = await stateB
+
+          if (stateA.done !== false || stateA.value !== 1) throw 'fail: f: next'
+          if (stateB.done !== true || stateB.value !== 2) throw 'fail: f: done'
+        }
+      `,
+    }, { async: true }),
+    test(['in.js', '--outfile=node.js', '--format=esm'].concat(flags), {
+      'in.js': `
+        async function* f(order) {
+          order.push('before')
+          await Promise.resolve()
+          return yield 1
+        }
+        export let async = async () => {
+          let it, stateA, stateB, order = []
+          it = f(order)
+          stateA = it.next()
+          stateB = it.next(2)
+          order.push('after')
+
+          stateA = await stateA
+          stateB = await stateB
+
+          if (order[0] !== 'before' || order[1] !== 'after') throw 'fail: f: order: ' + JSON.stringify(order)
+          if (stateA.done !== false || stateA.value !== 1) throw 'fail: f: next'
+          if (stateB.done !== true || stateB.value !== 2) throw 'fail: f: done'
+        }
+      `,
+    }, { async: true }),
+    test(['in.js', '--outfile=node.js', '--format=esm'].concat(flags), {
+      'in.js': `
+        async function* f(order) {
+          yield 0
+          order.push('before')
+          await Promise.resolve()
+          return yield 1
+        }
+        export let async = async () => {
+          let it, stateA, stateB, order = []
+          it = f(order)
+          await it.next()
+          stateA = it.next()
+          order.push('after')
+          stateB = it.next(2)
+
+          stateA = await stateA
+          stateB = await stateB
+
+          if (order[0] !== 'before' || order[1] !== 'after') throw 'fail: f: order: ' + JSON.stringify(order)
+          if (stateA.done !== false || stateA.value !== 1) throw 'fail: f: next'
+          if (stateB.done !== true || stateB.value !== 2) throw 'fail: f: done'
+        }
+      `,
+    }, { async: true }),
     test(['in.js', '--outfile=node.js', '--format=esm'].concat(flags), {
       'in.js': `
         async function* f() {