DDC fix for foreign futures

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
 /// stepping stone for proposed ES7 async/await, and uses ES6 Promises.
 part of dart._runtime;
 
 final _jsIterator = JS('', 'Symbol("_jsIterator")');
 final _current = JS('', 'Symbol("_current")');
 
 syncStar(gen, E, @rest args) => JS(
     '',
     '''(() => {
   const SyncIterable_E = ${getGenericClass(SyncIterable)}($E);
   return new SyncIterable_E($gen, $args);
 })()''');
 
 @JSExportName('async')
 async_(gen, T, @rest args) => JS(
     '',
     '''(() => {
   let iter;
+  const FutureT = ${getGenericClass(Future)}($T);
+  let _FutureType;
+  // Return the raw class type or null if not a class object.
+  // This is streamlined to test for native futures.
+  function _getRawClassType(obj) {
+    if (!obj) return null;
+    let constructor = obj.constructor;
+    if (!constructor == null) return null;
+    return $getGenericClass(constructor);
+  }
   function onValue(res) {
     if (res === void 0) res = null;
     return next(iter.next(res));
   }
   function onError(err) {
     // If the awaited Future throws, we want to convert this to an exception
     // thrown from the `yield` point, as if it was thrown there.
     //
     // If the exception is not caught inside `gen`, it will emerge here, which
     // will send it to anyone listening on this async function's Future<T>.
     //
     // 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) {
     let future = ret.value;
     if (ret.done) {
       return ret.value;
     }
-    // Checks if the awaited value is a Future.
-    if (!$instanceOf(future, $Future)) {
+    // Wraps if future is not a native Future.
+    if (_getRawClassType(future) !== _FutureType) {
       future = $Future.value(future);
     }
     // Chain the Future so `await` receives the Future's value.
     return future.then($dynamic)(onValue, {onError: onError});
   }
-  let FutureT = ${getGenericClass(Future)(T)};
-  return FutureT.microtask(function() {
+  let result = FutureT.microtask(function() {
     iter = $gen.apply(null, $args)[Symbol.iterator]();
     var result = onValue();
     if ($strongInstanceOf(result, FutureT) == null) {
       // Chain the Future<dynamic> to a Future<T> to produce the correct
       // final type.
       return result.then($T)((x) => x, {onError: onError});
     } else {
       return result;
     }
   });
+  // TODO(jmesserly): optimize this further.
+  _FutureType = _getRawClassType(result);
+  return result;  
 })()''');
 
 // Implementation inspired by _AsyncStarStreamController in
 // dart-lang/sdk's runtime/lib/core_patch.dart
 //
 // Given input like:
 //
 //     foo() async* {
 //       yield 1;
 //       yield* bar();
@@ skipping 155 matching lines @@
   }
 ''');
 
 /// Returns a Stream of T implemented by an async* function. */
 ///
 asyncStar(gen, T, @rest args) => JS(
     '',
     '''(() => {
   return new $_AsyncStarStreamController($gen, $T, $args).controller.stream;
 })()''');