Implementation of async-await transformation on js ast.

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:_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,
     leaveJsAsync,
     enterJsAsync,
     isWorker;
 
-import 'dart:async' show Future, DeferredLoadException, Completer;
+import 'dart:async'
+  show Future, DeferredLoadException, Completer, StreamController;
 
 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 3410 matching lines @@
   throw new MainError("No top-level function named 'main'.");
 }
 
 void badMain() {
   throw new MainError("'main' is not a function.");
 }
 
 void mainHasTooManyParameters() {
   throw new MainError("'main' expects too many parameters.");
 }
+
+/// Runtime support for async-await transformation.
+// If helperCallback is null we complete the completer with object.
+// If helperCallback or errorCallback throws we complete the completer with
+// the error.
+thenHelper(object,
+           helperCallback,
+           Completer completer,
+           errorCallback) {
+  if (helperCallback == null) {
+    completer.complete(object);
+    return;
+  }
+  Future future = object is Future ? object : new Future.value(object);
+  future.then(new WrappedJsFunction(helperCallback, completer),
+              onError: new WrappedJsFunction(errorCallback, completer));
+  return completer.future;
+}
+
+// Used to avoid creating two identical closure classes in [thenHelper].
+class WrappedJsFunction {
+  final function;
+  final Completer completer;
+
+  WrappedJsFunction(this.function, this.completer);
+
+  call(result) {
+    try {
+      JS('', '#(#)', function, result);
+    } catch (e, st) {
+      completer.completeError(e, st);
+    }
+  }
+}
+
+// If helperCallback is null we close the stream.
+// If helperCallback or errorCallback throws we add the error to the stream
+// If the object is a YIELD_SINGLE we add the object to the stream.
+streamHelper(object,
+           helperCallback,
+           StreamController controller,
+           errorCallback) {
+    print("Called with $controller");
+  if (helperCallback == null) {
+    // This happens on return from the async* function.
+    controller.close();
+    return;
+  }
+
+  if (object is IterationMarker) {
+    if (object.state == IterationMarker.YIELD_SINGLE) {
+      controller.add(object.value);
+    } else if (object.state == IterationMarker.YIELD_STAR) {
+      // TODO(sigurdm): Handle yield star from async*.
+    }
+    if (controller.isPaused) {
+      return;
+    } else if (controller.isCanceled) {
+      // TODO(sigurdm): Handle cancelled streams.
+    }
+    object = null;
+  }
+
+  Future future = object is Future ? object : new Future.value(object);
+  future.then(new WrappedJsFunctionForStream(helperCallback, controller),
+              onError: errorCallback = null
+                  ? null
+                  : new WrappedJsFunctionForStream(errorCallback,
+                                                   controller));
+  return controller.stream;
+}
+
+
+makeAsyncStarController(helperCallBack) {
+  StreamControllor c;
+  c = new StreamController(
+      onResume: () {
+    // TODO(sigurdm): The errorCallback should not be null.
+    streamHelper(null, helperCallBack, c, null);
+  });
+  return c;
+}
+
+// Used to avoid creating two identical closure classes in [streamHelper].
+class WrappedJsFunctionForStream {
+  final function;
+  final StreamController controller;
+
+  WrappedJsFunctionForStream(this.function, this.controller);
+
+  call(result) {
+    print(controller);
+    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;
+
+  final value;
+  final int state;
+
+  IterationMarker._(this.state, this.value);
+
+  static yieldStar(Iterable iterable) {
+    return new IterationMarker._(YIELD_STAR, iterable);
+  }
+
+  static endOfIteration() {
+    return new IterationMarker._(ITERATION_ENDED, null);
+  }
+
+  static yieldSingle(value) {
+    return new IterationMarker._(YIELD_SINGLE, value);
+  }
+
+  toString() => "IterationMarker($state, $value)";
+}
+
+class SyncStarIterator implements Iterator {
+  final helper;
+
+  var _current = null;
+  bool stillRunning = true;
+  bool runningNested = false;
+
+  get current => runningNested ? _current.current : _current;
+
+  SyncStarIterator(helper)
+      : helper = ((arg) => JS('', '#(#)', helper, arg));
+
+  bool moveNext() {
+    if (!stillRunning) return false;
+    if (runningNested) {
+      if (_current.moveNext()) {
+        return true;
+      } else {
+        runningNested = false;
+      }
+    }
+    _current = helper(null);
+    if (_current is IterationMarker) {
+      if (_current.state == IterationMarker.ITERATION_ENDED) {
+        _current = null;
+        stillRunning = false;
+      } else {
+        assert(_current.state == IterationMarker.YIELD_STAR);
+        _current = _current.value.iterator;
+        runningNested = true;
+        return moveNext();
+      }
+    }
+    return stillRunning;
+  }
+}
+
+class SyncStarIterable extends IterableBase {
+  final outerHelper;
+
+  SyncStarIterable(this.outerHelper);
+
+  Iterator get iterator => new SyncStarIterator(JS('', '#()', outerHelper));
+}
+