Move the try-catch out of the async-function

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,
@@ skipping 3571 matching lines @@
   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));
   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.
+    function(errorCode, result) {
+      while (true) {
+        try {
+          #(errorCode, result);
+          break;
+        } catch (error) {
+          result = error;
+          errorCode = #;
+        }
+      }
+    }""", function, async_error_codes.ERROR);
   return (result) {
-    JS('', '#(#, #)', function, errorCode, result);
+    JS('', '#(#, #)', protected, 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
 /// [asyncBody] == [async_error_codes.SUCCESS], the asyncStarHelper takes this
@@ skipping 149 matching lines @@
   }
 
   static uncaughtError(dynamic error) {
     return new IterationMarker._(UNCAUGHT_ERROR, error);
   }
 
   toString() => "IterationMarker($state, $value)";
 }
 
 class SyncStarIterator implements Iterator {
-  final Function _body;
+  final dynamic _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(body)
-      : _body = (() => JS('', '#()', body));
+  SyncStarIterator(this._body);
+
+  runBody() {

[sra1, 2015/02/27 20:34:51]

Make this private, otherwise I can call it from user code.

I also see that dart2js inlined the code into moveNext.
That does not seem to do any harm, but if you want to prevent that, use
@NoInline().

[sigurdm, 2015/03/02 09:14:47]

Good point. Thanks

+    return JS('', '''
+      // Invokes [body] with [errorCode] and [result].
+      //
+      // If (and as long as) the invocation throws, calls [function] again,
+      // with an error-code.
+      (function(body) {
+        var errorValue, errorCode = #;
+        while (true) {
+          try {
+            return body(errorCode, errorValue);
+          } catch (error) {
+            errorValue = error;
+            errorCode = #
+          }
+        }
+      })(#)''', async_error_codes.SUCCESS, async_error_codes.ERROR, _body);
+  }
+
 
   bool moveNext() {
     if (_runningNested) {
       if (_current.moveNext()) {
         return true;
       } else {
         _runningNested = false;
       }
     }
-    _current = _body();
+    _current = runBody();
     if (_current is IterationMarker) {
       if (_current.state == IterationMarker.ITERATION_ENDED) {
         _current = null;
         // 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 {
@@ skipping 14 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));
 }