Dart2js async* functions only resume execution of the body when suspended on yield.

sdk/lib/_internal/compiler/js_lib/js_helper.dart

Index: sdk/lib/_internal/compiler/js_lib/js_helper.dart
diff --git a/sdk/lib/_internal/compiler/js_lib/js_helper.dart b/sdk/lib/_internal/compiler/js_lib/js_helper.dart
index 163833b6ffadbac2da7a19366980a6bcf9041896..d2b6795ce42eea337c8c28328a3af380b530af83 100644
--- a/sdk/lib/_internal/compiler/js_lib/js_helper.dart
+++ b/sdk/lib/_internal/compiler/js_lib/js_helper.dart
@@ -3741,6 +3741,7 @@ void asyncStarHelper(dynamic object,
       return;
     }
     if (object.state == IterationMarker.YIELD_SINGLE) {
+      controller.isWaitingForYield = true;
       controller.add(object.value);
       // If the controller is paused we stop producing more values.
       if (controller.isPaused) {
@@ -3748,6 +3749,7 @@ void asyncStarHelper(dynamic object,
       }
       // TODO(sigurdm): We should not suspend here according to the spec.

[Lasse Reichstein Nielsen, 2015/04/08 14:12:14]

Isn't the spec allowing you to do so, but not requiring it (as long as you
"eventually" break a loop of yields)?
I think it's the right thing to do - output the value, allow the listener to
process it, then go back to creating the next value.

[sigurdm, 2015/04/09 11:24:08]

Yes I think so - this is an outdated comment. Removed.

       scheduleMicrotask(() {
+        controller.isWaitingForYield = false;

[Lasse Reichstein Nielsen, 2015/04/08 14:12:15]

I think this line should be moved outside of the scheduleMicrotask. At the time
you do the scheduleMicrotask, you have already decided that you are not paused,
and execution will continue. Alternatively, as written below, do the isPaused
check in the scheduleMicrotask callback.

[sigurdm, 2015/04/09 11:24:08]

Done.

         _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
                                 async_error_codes.SUCCESS)
             (null);
@@ -3796,6 +3798,8 @@ class AsyncStarStreamController {
   bool get isCanceled => cancelationCompleter != null;
   bool isAdding = false;
   bool isPaused = false;
+  bool isWaitingForYield = false;

[floitsch, 2015/04/08 14:01:25]

isAtYield ?

Add comment what exactly this means. For example.
/// True, when the async* function just yielded a value, but hasn't
/// resumed execution yet.

[sigurdm, 2015/04/08 14:07:40]

Done.

[Lasse Reichstein Nielsen, 2015/04/08 14:12:14]

Consider documenting these fields, preferably by describing the possible states
that they controller can be in (including any scheduleMicrotask callbacks that
may be scheduled in some states). 
I find that being extremely explicit about the states is the best way to avoid
an accidental inconsistent state. 

[sigurdm, 2015/04/09 11:24:08]

Good advice!
I realized I can leave out `isAdding` it contains no useful information beyond
isSuspended. Similarly i maintained my own isPaused to be able to decide if to
resume after onCancel. That should depend only on isSuspended.

+
   add(event) => controller.add(event);
   addStream(Stream stream) {
     return controller.addStream(stream, cancelOnError: false);
@@ -3807,8 +3811,8 @@ class AsyncStarStreamController {
     controller = new StreamController(
       onListen: () {
         scheduleMicrotask(() {
-          Function wrapped = _wrapJsFunctionForAsync(body,
-                                                     async_error_codes.SUCCESS);
+          Function wrapped =
+              _wrapJsFunctionForAsync(body, async_error_codes.SUCCESS);
           wrapped(null);
         });
       },
@@ -3816,7 +3820,7 @@ class AsyncStarStreamController {
         isPaused = true;
       }, onResume: () {
         isPaused = false;
-        if (!isAdding) {
+        if (!isAdding && isWaitingForYield) {

[Lasse Reichstein Nielsen, 2015/04/08 14:12:15]

I don't think this is safe enough. 
If the stream becomes both paused after setting isWaitingForYield to true, but
before the following scheduleMicrotask callback being run, and it is also
resumed again in that time, then this code will run *as well* as the
scheduleMicrotask callback.

[Lasse Reichstein Nielsen, 2015/04/08 14:12:15]

Maybe name it "isWaitingForResume"? You have already executed the yield, and is
now blocked after the yield because the output stream subscription is paused.

Should isWaitingForYield be set to false somewhere?

[sigurdm, 2015/04/09 11:24:08]

It is now isSuspended

           asyncStarHelper(null, body, this);
         }
       }, onCancel: () {