More tests for async* functions

sdk/lib/_internal/js_runtime/lib/async_patch.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Patch file for the dart:async library.
 
 import 'dart:_js_helper' show
     patch,
     ExceptionAndStackTrace,
     Primitives,
@@ skipping 237 matching lines @@
 /// [IterationMarker] to the stream. If the stream subscription has been
 /// paused, return early. Otherwise schedule the helper function to be
 /// executed again.
 ///
 /// If [object] is a yield-star [IterationMarker], starts listening to the
 /// yielded stream, and adds all events and errors to our own controller (taking
 /// care if the subscription has been paused or canceled) - when the sub-stream
 /// is done, schedules [asyncBody] again.
 ///
 /// If the async* function wants to do an await it calls this function with
-/// [object] not and [IterationMarker].
+/// [object] not an [IterationMarker].
 ///
 /// If [object] is not a [Future], it is wrapped in a `Future.value`.
 /// The [asyncBody] is called on completion of the future (see [asyncHelper].
+/// If the stream has been canceled in the meantime, the body is
+/// called with [async_error_codes.STREAM_WAS_CANCELED] once the future
+/// completes.

[Lasse Reichstein Nielsen, 2016/02/08 17:44:24]

That's not correct.
Canceled async* functions must only (attempt to) exit at a yield, not at an
await. That's documented above. It *must not* exit at an await.

[Lasse Reichstein Nielsen, 2016/02/08 20:54:44]

(or maybe I'm not understanding exactly what happens when this function is
called).

[floitsch, 2016/02/09 16:56:34]

My fault. I reverted these changes.

 void _asyncStarHelper(dynamic object,
     dynamic /* int | _WrappedAsyncBody */ bodyFunctionOrErrorCode,
     _AsyncStarStreamController controller) {
   if (identical(bodyFunctionOrErrorCode, async_error_codes.SUCCESS)) {
     // This happens on return from the async* function.
     if (controller.isCanceled) {
       controller.cancelationCompleter.complete();
     } else {
       controller.close();
     }
@@ skipping 43 matching lines @@
         // after insertion of each element.
         int errorCode = controller.isCanceled
             ? async_error_codes.STREAM_WAS_CANCELED
             : async_error_codes.SUCCESS;
         bodyFunctionOrErrorCode(errorCode, null);
       });
       return;
     }
   }
 
-  _awaitOnObject(object, bodyFunctionOrErrorCode);
+  // Executes the body-function, unless the subscription was canceled while
+  // waiting for the object.
+  void runBodyOrCancel(int errorCode, dynamic result) {
+    if (controller.isCanceled) {
+      bodyFunctionOrErrorCode(async_error_codes.STREAM_WAS_CANCELED, null);
+      return;
+    }
+    bodyFunctionOrErrorCode(errorCode, result);
+  }
+
+  _awaitOnObject(object, runBodyOrCancel);
 }
 
 Stream _streamOfController(_AsyncStarStreamController controller) {
   return controller.stream;
 }
 
 /// A wrapper around a [StreamController] that keeps track of the state of
 /// the execution of an async* function.
 /// It can be in 1 of 3 states:
 ///
@@ skipping 180 matching lines @@
 
   Iterator get iterator => new _SyncStarIterator(JS('', '#()', _outerHelper));
 }
 
 @patch
 void _rethrow(Object error, StackTrace stackTrace) {
   error = wrapException(error);
   JS("void", "#.stack = #", error, stackTrace.toString());
   JS("void", "throw #", error);
 }