Dart2js async-await. Propagate stacktraces from futures.

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
     JsGetName,
@@ skipping 1766 matching lines @@
       if (thrownStackTrace == null) {
         JS('void', r'#.$thrownJsError = #', error, ex);
       }
     }
     return error;
   }
 
   // Note that we are checking if the object has the property. If it
   // has, it could be set to null if the thrown value is null.
   if (ex == null) return null;
+  if (ex is ExceptionAndStackTrace) {
+    return saveStackTrace(ex.dartException);
+  }
   if (JS('bool', 'typeof # !== "object"', ex)) return ex;
 
   if (JS('bool', r'"dartException" in #', ex)) {
     return saveStackTrace(JS('', r'#.dartException', ex));
   } else if (!JS('bool', r'"message" in #', ex)) {
     return ex;
   }
 
   // Grab hold of the exception message. This field is available on
   // all supported browsers.
@@ skipping 103 matching lines @@
   // Just return the exception. We should not wrap it because in case
   // the exception comes from the DOM, it is a JavaScript
   // object backed by a native Dart class.
   return ex;
 }
 
 /**
  * Called by generated code to fetch the stack trace from an
  * exception. Should never return null.
  */
-StackTrace getTraceFromException(exception) => new _StackTrace(exception);
+StackTrace getTraceFromException(exception) {
+  if (exception is ExceptionAndStackTrace) {
+    return exception.stackTrace;
+  }
+  return new _StackTrace(exception);
+}
 
 class _StackTrace implements StackTrace {
   var _exception;
   String _trace;
   _StackTrace(this._exception);
 
   String toString() {
     if (_trace != null) return JS('String', '#', _trace);
 
     String trace;
@@ skipping 1628 matching lines @@
 }
 
 void badMain() {
   throw new MainError("'main' is not a function.");
 }
 
 void mainHasTooManyParameters() {
   throw new MainError("'main' expects too many parameters.");
 }
 
+/// A wrapper around an exception, much like the one created by [wrapException]
+/// but with a pre-given stack-trace.
+class ExceptionAndStackTrace {
+  dynamic dartException;
+  StackTrace stackTrace;
+
+  ExceptionAndStackTrace(this.dartException, this.stackTrace);
+}
+
 /// 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 [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].
@@ skipping 11 matching lines @@
     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(_wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
                                       async_error_codes.SUCCESS),
-      onError: _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
-                                       async_error_codes.ERROR));
+      onError: (dynamic error, StackTrace stackTrace) {
+        ExceptionAndStackTrace wrapped =
+            new ExceptionAndStackTrace(error, stackTrace);
+        return _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+                                       async_error_codes.ERROR)(wrapped);
+      });
   return completer.future;
 }
 
 Function _wrapJsFunctionForAsync(dynamic /* js function */ function,
                                  int errorCode) {
   var protected = JS('', """
     // Invokes [function] with [errorCode] and [result].
     //
     // If (and as long as) the invocation throws, calls [function] again,
     // with an error-code.
@@ skipping 94 matching lines @@
         _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
                                 async_error_codes.SUCCESS)(null);
       });
       return;
     }
   }
 
   Future future = object is Future ? object : new Future.value(object);
   future.then(_wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
                                       async_error_codes.SUCCESS),
-              onError: _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
-                                               async_error_codes.ERROR));
+              onError: (error, StackTrace stackTrace) {
+                ExceptionAndStackTrace wrapped =
+                    new ExceptionAndStackTrace(error, stackTrace);
+                return _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
+                                               async_error_codes.ERROR)
+                    (wrapped);
+              });
 }
 
 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) {
+  AsyncStarStreamController(body) {
     controller = new StreamController(
       onListen: () {
         scheduleMicrotask(() {
-          JS('', '#(#, null)', helperCallback, async_error_codes.SUCCESS);
+          _wrapJsFunctionForAsync(body,
+                                  async_error_codes.SUCCESS)(null);
         });
       },
       onResume: () {
         if (!isAdding) {
-          asyncStarHelper(null, helperCallback, this);
+          asyncStarHelper(null, body, this);
         }
       }, onCancel: () {
         stopRunning = true;
       });
   }
 }
 
-makeAsyncStarController(helperCallback) {
-  return new AsyncStarStreamController(helperCallback);
+makeAsyncStarController(body) {
+  return new AsyncStarStreamController(body);
 }
 
 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;
@@ skipping 87 matching lines @@
   // This is a function that will return a helper function that does the
   // iteration of the sync*.
   //
   // Each invocation should give a body with fresh state.
   final dynamic /* js function */ _outerHelper;
 
   SyncStarIterable(this._outerHelper);
 
   Iterator get iterator => new SyncStarIterator(JS('', '#()', _outerHelper));
 }