Merge request - fixes dart2js async problems.

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

 // Copyright (c) 2013, 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.
 
 library _js_helper;
 
+import 'dart:_async_await_error_codes' as async_error_codes;
+
 import 'dart:_js_embedded_names' show
     GET_TYPE_FROM_NAME,
     GET_ISOLATE_TAG,
     INTERCEPTED_NAMES,
     INTERCEPTORS_BY_TAG,
     LEAF_TAGS,
     METADATA,
     DEFERRED_LIBRARY_URIS,
     DEFERRED_LIBRARY_HASHES,
     INITIALIZE_LOADED_HUNK,
     IS_HUNK_LOADED,
     IS_HUNK_INITIALIZED,
     NATIVE_SUPERCLASS_TAG_NAME;
 
 import 'dart:collection';
 import 'dart:_isolate_helper' show
     IsolateNatives,
     enterJsAsync,
     isWorker,
     leaveJsAsync;
 
 import 'dart:async' show
-  Future,
-  DeferredLoadException,
-  Completer,
-  StreamController,
-  Stream,
-  StreamSubscription,
-  scheduleMicrotask;
+    Future,
+    DeferredLoadException,
+    Completer,
+    StreamController,
+    Stream,
+    StreamSubscription,
+    scheduleMicrotask;
 
 import 'dart:_foreign_helper' show
     DART_CLOSURE_TO_JS,
     JS,
     JS_CALL_IN_ISOLATE,
     JS_CONST,
     JS_CURRENT_ISOLATE,
     JS_CURRENT_ISOLATE_CONTEXT,
     JS_DART_OBJECT_CONSTRUCTOR,
     JS_EFFECT,
@@ skipping 3424 matching lines @@
   throw new MainError("'main' expects too many parameters.");
 }
 
 /// Runtime support for async-await transformation.
 ///
 /// This function is called by a transformed function on each await and return
 /// in the untransformed function, and before starting.
 ///
 /// If [object] is not a future it will be wrapped in a `new Future.value`.
 ///
-/// If [helperCallback] is null it indicates a return from the async function,
-/// and we complete the completer with object.
+/// If [asyncBody] is [async_error_codes.SUCCESS]/[async_error_codes.ERROR] it
+/// indicates a return or throw from the async function, and
+/// complete/completeError is called on [completer] with [object].
 ///
-/// Otherwise [helperCallback] is set up to be called when the future is
-/// successfull and [errorCallback] if it is completed with an error.
-///
-/// If helperCallback or errorCallback throws we complete the completer with the
-/// error.
+/// Otherwise [asyncBody] is set up to be called when the future is completed
+/// with a code [async_error_codes.SUCCESS]/[async_error_codes.ERROR] depending
+/// on the success of the future.
 ///
 /// Returns the future of the completer for convenience of the first call.
-dynamic thenHelper(dynamic object,
-                   dynamic /* js function */ helperCallback,
-                   Completer completer,
-                   dynamic /* js function */ errorCallback) {
-  if (helperCallback == null) {
+dynamic asyncHelper(dynamic object,
+                    dynamic /* js function */ bodyFunctionOrErrorCode,
+                    Completer completer) {
+  if (identical(bodyFunctionOrErrorCode, async_error_codes.SUCCESS)) {
     completer.complete(object);
     return;
+  } else if (identical(bodyFunctionOrErrorCode, async_error_codes.ERROR)) {
+    // The error is a js-error.
+    completer.completeError(unwrapException(object),
+                            getTraceFromException(object));
+    return;
   }
   Future future = object is Future ? object : new Future.value(object);
-  future.then(_wrapJsFunctionForThenHelper(helperCallback, completer),
-              onError: (errorCallback == null)
-                  ? null
-                  : _wrapJsFunctionForThenHelper(errorCallback, completer));
+  future.then(_wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+                                      async_error_codes.SUCCESS),
+      onError: _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+                                       async_error_codes.ERROR));
   return completer.future;
 }
 
-Function _wrapJsFunctionForThenHelper(dynamic /* js function */ function,
-                                      Completer completer) {
+Function _wrapJsFunctionForAsync(dynamic /* js function */ function,
+                                 int errorCode) {
   return (result) {
-    try {
-      JS('', '#(#)', function, result);
-    } catch (e, st) {
-      completer.completeError(e, st);
-    }
+    JS('', '#(#, #)', function, errorCode, result);
   };
 }
 
-
 /// Implements the runtime support for async* functions.
 ///
 /// Called by the transformed function for each original return, await, yield,
 /// yield* and before starting the function.
 ///
-/// When the async* function wants to return it calls this function. with
-/// [helperCallback] == null, the streamHelper takes this as signal to close the
-/// stream.
+/// When the async* function wants to return it calls this function with
+/// [asyncBody] == [async_error_codes.SUCCESS], the asyncStarHelper takes this
+/// as signal to close the stream.
 ///
-/// If the async* function wants to do a yield or yield* it calls this function
-/// with [object] being an [IterationMarker]. In this case [errorCallback] has a
-/// special meaning; it is a callback that will run all enclosing finalizers.
+/// When the async* function wants to signal that an uncaught error was thrown,
+/// it calls this function with [asyncBody] == [async_error_codes.ERROR],
+/// the streamHelper takes this as signal to addError [object] to the
+/// [controller] and close it.
+///
+/// If the async* function wants to do a yield or yield*, it calls this function
+/// with [object] being an [IterationMarker].
 ///
 /// In the case of a yield or yield*, if the stream subscription has been
-/// canceled [errorCallback] is scheduled.
+/// canceled, schedules [asyncBody] to be called with
+/// [async_error_codes.STREAM_WAS_CANCELED].
 ///
 /// If [object] is a single-yield [IterationMarker], adds the value of the
 /// [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 [helperCallback] again.
+/// is done, schedules [asyncBody] again.
 ///
 /// If the async* function wants to do an await it calls this function with
 /// [object] not and [IterationMarker].
 ///
 /// If [object] is not a [Future], it is wrapped in a `Future.value`.
-/// The [helperCallback] is called on successfull completion of the
-/// future.
-///
-/// If [helperCallback] or [errorCallback] throws the error is added to the
-/// stream.
-void streamHelper(dynamic object,
-                     dynamic /* js function */ helperCallback,
-                     AsyncStarStreamController controller,
-                     dynamic /* js function */ errorCallback) {
-  if (helperCallback == null) {
+/// The [asyncBody] is called on completion of the future (see [asyncHelper].
+void asyncStarHelper(dynamic object,
+                     dynamic /* int | js function */ bodyFunctionOrErrorCode,
+                     AsyncStarStreamController controller) {
+  if (identical(bodyFunctionOrErrorCode, async_error_codes.SUCCESS)) {
     // This happens on return from the async* function.
     controller.close();
     return;
+  } else if (identical(bodyFunctionOrErrorCode, async_error_codes.ERROR)) {
+    // The error is a js-error.
+    controller.addError(unwrapException(object),
+                        getTraceFromException(object));
+    controller.close();
+    return;
   }
 
   if (object is IterationMarker) {
     if (controller.stopRunning) {
-      _wrapJsFunctionForStream(errorCallback, controller)();
+      _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+          async_error_codes.STREAM_WAS_CANCELED)(null);
       return;
     }
     if (object.state == IterationMarker.YIELD_SINGLE) {
       controller.add(object.value);
       // If the controller is paused we stop producing more values.
       if (controller.isPaused) {
         return;
       }
       // TODO(sigurdm): We should not suspend here according to the spec.
       scheduleMicrotask(() {
-          _wrapJsFunctionForStream(helperCallback, controller)(null);
+        _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+                                async_error_codes.SUCCESS)
+            (null);
       });
       return;
     } else if (object.state == IterationMarker.YIELD_STAR) {
       Stream stream = object.value;
       controller.isAdding = true;
       // Errors of [stream] are passed though to the main stream. (see
       // [AsyncStreamController.addStream].
       // TODO(sigurdm): The spec is not very clear here. Clarify with Gilad.
       controller.addStream(stream).then((_) {
         controller.isAdding = false;
-        _wrapJsFunctionForStream(helperCallback, controller)(null);
+        _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+                                async_error_codes.SUCCESS)(null);
       });
       return;
     }
   }
 
   Future future = object is Future ? object : new Future.value(object);
-  future.then(_wrapJsFunctionForStream(helperCallback, controller),
-              onError: errorCallback == null
-                  ? null
-                  : _wrapJsFunctionForStream(errorCallback, controller));
+  future.then(_wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+                                      async_error_codes.SUCCESS),
+              onError: _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+                                               async_error_codes.ERROR));
 }
 
 Stream streamOfController(AsyncStarStreamController controller) {
   return controller.stream;
 }
 
 /// A wrapper around a [StreamController] that remembers if that controller
 /// got a cancel.
 ///
 /// Also has a subSubscription that when not null will provide events for the
 /// stream, and will be paused and resumed along with this controller.
 class AsyncStarStreamController {
   StreamController controller;
   Stream get stream => controller.stream;
   bool stopRunning = false;
   bool isAdding = false;
   bool get isPaused => controller.isPaused;
   add(event) => controller.add(event);
   addStream(Stream stream) {
     return controller.addStream(stream, cancelOnError: false);
   }
   addError(error, stackTrace) => controller.addError(error, stackTrace);
   close() => controller.close();
 
   AsyncStarStreamController(helperCallback) {
     controller = new StreamController(
       onListen: () {
-        scheduleMicrotask(() => JS('', '#(null)', helperCallback));
+        scheduleMicrotask(() {
+          JS('', '#(#, null)', helperCallback, async_error_codes.SUCCESS);
+        });
       },
       onResume: () {
         if (!isAdding) {
-          streamHelper(null, helperCallback, this, null);
+          asyncStarHelper(null, helperCallback, this);
         }
       }, onCancel: () {
         stopRunning = true;
       });
   }
 }
 
 makeAsyncStarController(helperCallback) {
   return new AsyncStarStreamController(helperCallback);
 }
 
-Function _wrapJsFunctionForStream(dynamic /* js function */ function,
-                                  AsyncStarStreamController controller) {
-  return (result) {
-    try {
-      JS('', '#(#)', function, result);
-    } catch (e, st) {
-      controller.addError(e, st);
-    }
-  };
-}
-
-
 class IterationMarker {
   static const YIELD_SINGLE = 0;
   static const YIELD_STAR = 1;
   static const ITERATION_ENDED = 2;
+  static const UNCAUGHT_ERROR = 3;
 
   final value;
   final int state;
 
   IterationMarker._(this.state, this.value);
 
   static yieldStar(dynamic /* Iterable or Stream */ values) {
     return new IterationMarker._(YIELD_STAR, values);
   }
 
   static endOfIteration() {
     return new IterationMarker._(ITERATION_ENDED, null);
   }
 
   static yieldSingle(dynamic value) {
     return new IterationMarker._(YIELD_SINGLE, value);
   }
 
+  static uncaughtError(dynamic error) {
+    return new IterationMarker._(UNCAUGHT_ERROR, error);
+  }
+
   toString() => "IterationMarker($state, $value)";
 }
 
 class SyncStarIterator implements Iterator {
-  final Function _helper;
+  final Function _body;
 
   // If [runningNested] this is the nested iterator, otherwise it is the
   // current value.
   dynamic _current = null;
   bool _runningNested = false;
 
   get current => _runningNested ? _current.current : _current;
 
-  SyncStarIterator(helper)
-      : _helper = ((arg) => JS('', '#(#)', helper, arg));
+  SyncStarIterator(body)
+      : _body = (() => JS('', '#()', body));
 
   bool moveNext() {
     if (_runningNested) {
       if (_current.moveNext()) {
         return true;
       } else {
         _runningNested = false;
       }
     }
-    _current = _helper(null);
+    _current = _body();
     if (_current is IterationMarker) {
       if (_current.state == IterationMarker.ITERATION_ENDED) {
         _current = null;
-        // Rely on [_helper] to repeatedly return `ITERATION_ENDED`.
+        // Rely on [_body] to repeatedly return `ITERATION_ENDED`.
         return false;
+      } else if (_current.state == IterationMarker.UNCAUGHT_ERROR) {
+        // Rely on [_body] to repeatedly return `UNCAUGHT_ERROR`.
+        // This is a wrapped exception, so we use JavaScript throw to throw it.
+        JS('', 'throw #', _current.value);
       } else {
         assert(_current.state == IterationMarker.YIELD_STAR);
         _current = _current.value.iterator;
         _runningNested = true;
         return moveNext();
       }
     }
     return true;
   }
 }
 
 /// An Iterable corresponding to a sync* method.
 ///
 /// Each invocation of a sync* method will return a new instance of this class.
 class SyncStarIterable extends IterableBase {
   // This is a function that will return a helper function that does the
   // iteration of the sync*.
   //
-  // Each invocation should give a helper with fresh state.
+  // Each invocation should give a body with fresh state.
   final dynamic /* js function */ _outerHelper;
 
   SyncStarIterable(this._outerHelper);
 
   Iterator get iterator => new SyncStarIterator(JS('', '#()', _outerHelper));
 }