Fix spurious resume when awaiting future in async* code

runtime/lib/core_patch.dart

Index: runtime/lib/core_patch.dart
===================================================================
--- runtime/lib/core_patch.dart	(revision 44981)
+++ runtime/lib/core_patch.dart	(working copy)
@@ -36,12 +36,14 @@
   bool isAdding = false;
   bool onListenReceived = false;
   bool isScheduled = false;
+  bool isSuspendedAtYield = false;
   Completer cancellationCompleter = null;
 
   Stream get stream => controller.stream;
 
   void runBody() {
     isScheduled = false;
+    isSuspendedAtYield = false;

[Lasse Reichstein Nielsen, 2015/04/09 06:35:30]

If I understand this correctly, your possible states are:
- scheduled/running (some behavior depends on whether it's canceled)
- adding
- suspended
- done (reached end of function)
While running, even with async code, the async-star controller isn't invoked.
Only when you reach a yield, yield* or exit of the function will the controller
be used.

At a yield*, the state transitions to "adding". When the addStream completion
Future completes, state transitions to scheduled/running (there is no cancel or
pause check after a yield*, only before).

At a yield:
- if canceled, transition to scheduled (and try to exit).
- if paused, transition to suspended.
- otherwise, transition to scheduled (keep running)

On a resume, if suspended, transition to scheduled.

On a cancel, if suspended, transition to scheduled (and set the "cancelled" flag
so yields start trying to exit).

When exiting function, transition to done.


The boolean flags matches this (I think), but if the code was more explicit
about these states, I think the code would be easier to reason about (at least
for me :).

[hausner, 2015/04/09 17:10:19]

I agree that the code and comments could be clearer about the various states. I
don't have a clear picture of the various events and states that streams,
controllers, listeners etc can be in, so this code is more ad-hoc than I'd like.

     asyncStarBody();
   }
 
@@ -62,15 +64,17 @@
   // The generator would translate a 'yield e' statement to
   // controller.add(e);
   // suspend;
-  // if (controller.isCanelled) return;
+  // if (controller.isCancelled) return;
   bool add(event) {
     if (!onListenReceived) _fatal("yield before stream is listened to!");
+    if (isSuspendedAtYield) _fatal("unexpected yield");
     // If stream is cancelled, tell caller to exit the async generator.
     if (!controller.hasListener) {
       return true;
     }
     controller.add(event);
     scheduleGenerator();
+    isSuspendedAtYield = true;
     return false;
   }
 
@@ -131,7 +135,9 @@
   }
 
   onResume() {
-    scheduleGenerator();
+    if (isSuspendedAtYield) {
+      scheduleGenerator();
+    }
   }
 
   onCancel() {