Use microtasks in dart.async

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/generators.dart

 // Copyright (c) 2015, 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.
 
 /// This library adapts ES6 generators to implement Dart's async/await.
 /// It's designed to interact with Dart's Future/Stream and follow Dart
 /// async/await semantics.
 /// See https://github.com/dart-lang/sdk/issues/27315 for ideas on
 /// reconciling Dart's Future and ES6 Promise.
 /// Inspired by `co`: https://github.com/tj/co/blob/master/index.js, which is a
@@ skipping 24 matching lines @@
     //
     // In essence, we are giving the code inside the generator a chance to
     // use try-catch-finally.
     return next(iter.throw(err));
   }
   function next(ret) {
     if (ret.done) return ret.value;
     // Checks if the awaited value is a Future.
     let future = ret.value;
     if (!$instanceOf(future, ${getGenericClass(Future)})) {
-      future = $Future.value(future);
+      var result = future;

[Jennifer Messerly, 2017/01/25 18:31:17]

as noted, this change appears to contradict the spec for "await"

+      future = $Future.microtask(() => result);
     }
     // Chain the Future so `await` receives the Future's value.
     return future.then($dynamic)(onValue, {onError: onError});
   }
-  return ${getGenericClass(Future)}($T).new(function() {
+  return ${getGenericClass(Future)}($T).microtask(function() {

[Jennifer Messerly, 2017/01/25 18:31:17]

here's the spec for the return value, 16.14 Function Invocation:

If f is marked async (9), then a fresh instance (10.6.1) o implementing the
built-in class Future is associated with the invocation and immediately returned
to the caller. The body of f is scheduled for execution at some future time. The
future o will complete when f terminates. The value used to complete o is the
current return value (17.12), if it is defined, and the current exception (16.9)
otherwise.

... so it sounds like we should be using Completer not for "await" (spec'd to
Future.value). The correct code here would be:

    let c = ${getGenericClass(Completer)}($T);
    // ... schedule generator somehow ...
    return c.future;

the spec doesn't seem to say anything about what the scheduling should be for
this ("some future time").  If dart2js uses microtask we could certainly do a
scheduleMicrotask there. But I'd want to do our homework that this is actually
how dart2js/VM behaves... maybe look at their implementations or look at dart2js
generated code for a simple example

     iter = $gen.apply(null, $args)[Symbol.iterator]();
     return onValue();
   });
 })()''');
 
 // Implementation inspired by _AsyncStarStreamController in
 // dart-lang/sdk's runtime/lib/core_patch.dart
 //
 // Given input like:
 //
@@ skipping 154 matching lines @@
       this.controller.addError(error, stackTrace);
     }
   }
 ''');
 
 /// Returns a Stream of T implemented by an async* function. */
 ///
 asyncStar(gen, T, @rest args) => JS('', '''(() => {
   return new $_AsyncStarStreamController($gen, $T, $args).controller.stream;
 })()''');