Fixes #178

lib/runtime/dart/async.js

 var async = dart.defineLibrary(async, {});
 var core = dart.import(core);
 var _internal = dart.import(_internal);
 var _js_helper = dart.lazyImport(_js_helper);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 var collection = dart.import(collection);
 (function(exports, core, _internal, _js_helper, _isolate_helper, collection) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
@@ skipping 196 matching lines @@
             },
             onCancel: () => {
               subscription.cancel();
             },
             sync: true
           });
         }
         return controller.stream;
       }
       asyncExpand(convert) {
-        dart.as(convert, dart.functionType(Stream, [T]));
+        dart.as(convert, dart.functionType(Stream$(), [T]));
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         let onListen = (() => {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           subscription = this.listen(event => {
             dart.as(event, T);
             let newStream = null;
             try {
@@ skipping 628 matching lines @@
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
         return dart.notNull(dart.hashCode(this[_controller])) ^ 892482866;
       }
       ['=='](other) {
         if (core.identical(this, other))
           return true;
-        if (!dart.is(other, _ControllerStream))
+        if (!dart.is(other, _ControllerStream$()))
           return false;
-        let otherStream = dart.as(other, _ControllerStream);
+        let otherStream = dart.as(other, _ControllerStream$());
         return core.identical(otherStream[_controller], this[_controller]);
       }
     }
     return _ControllerStream;
   });
   let _ControllerStream = _ControllerStream$();
   let _BroadcastStream$ = dart.generic(function(T) {
     class _BroadcastStream extends _ControllerStream$(T) {
       _BroadcastStream(controller) {
         super._ControllerStream(dart.as(controller, _StreamControllerLifecycle$(T)));
@@ skipping 949 matching lines @@
         let remaining = 0;
         let error = null;
         let stackTrace = null;
         // Function handleError: (dynamic, dynamic) → void
         let handleError = (theError, theStackTrace) => {
           remaining = dart.notNull(remaining) - 1;
           if (values != null) {
             if (cleanUp != null) {
               for (let value of values) {
                 if (value != null) {
-                  new Future.sync(() => {
+                  new (Future$()).sync(() => {
                     dart.dcall(cleanUp, value);
                   });
                 }
               }
             }
             values = null;
             if (remaining == 0 || dart.notNull(eagerError)) {
               result[_completeError](theError, dart.as(theStackTrace, core.StackTrace));
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
           } else if (remaining == 0 && !dart.notNull(eagerError)) {
             result[_completeError](error, stackTrace);
           }
         };
         for (let future of futures) {
           let pos = remaining;
           remaining = dart.notNull(pos) + 1;
           future.then(value => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
               values[core.$set](pos, value);
               if (remaining == 0) {
                 result[_completeWithValue](values);
               }
             } else {
               if (dart.notNull(cleanUp != null) && dart.notNull(value != null)) {
-                new Future.sync(() => {
+                new (Future$()).sync(() => {
                   dart.dcall(cleanUp, value);
                 });
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result[_completeError](error, stackTrace);
               }
             }
           }, {onError: handleError});
         }
         if (remaining == 0) {
           return new (Future$(core.List)).value(dart.const([]));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
         let iterator = input[core.$iterator];
         return Future.doWhile(() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
-          return new Future.sync(() => dart.dcall(f, iterator.current)).then(_ => true);
+          return new (Future$()).sync(() => dart.dcall(f, iterator.current)).then(_ => true);
         });
       }
       static doWhile(f) {
         dart.as(f, dart.functionType(dart.dynamic, []));
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback(keepGoing => {
           if (keepGoing) {
-            new Future.sync(f).then(dart.as(nextIteration, __CastType4), {onError: doneSignal[_completeError].bind(doneSignal)});
+            new (Future$()).sync(f).then(dart.as(nextIteration, __CastType4), {onError: doneSignal[_completeError].bind(doneSignal)});
           } else {
             doneSignal[_complete](null);
           }
         }, {runGuarded: true});
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
@@ skipping 255 matching lines @@
           dart.assert(!dart.notNull(this[_isComplete]));
           this[_state] = _Future._CHAINED;
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future._INCOMPLETE;
         }
       }
       then(f, opts) {
         dart.as(f, dart.functionType(dart.dynamic, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
-        let result = new _Future();
+        let result = new (_Future$())();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           f = dart.as(result[_zone].registerUnaryCallback(f), __CastType6);
           if (onError != null) {
             onError = _registerErrorHandler(onError, result[_zone]);
           }
         }
         this[_addListener](new _FutureListener.then(result, f, onError));
         return result;
       }
       catchError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
         dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
-        let result = new _Future();
+        let result = new (_Future$())();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           onError = _registerErrorHandler(onError, result[_zone]);
           if (test != null)
             test = dart.as(result[_zone].registerUnaryCallback(test), __CastType8);
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
         dart.as(action, dart.functionType(dart.dynamic, []));
@@ skipping 53 matching lines @@
         while (current != null) {
           let next = current[_nextListener];
           current[_nextListener] = prev;
           prev = current;
           current = next;
         }
         return prev;
       }
       static _chainForeignFuture(source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
-        dart.assert(!dart.is(source, _Future));
+        dart.assert(!dart.is(source, _Future$()));
         target[_isChained] = true;
         source.then(value => {
           dart.assert(target[_isChained]);
           target[_completeWithValue](value);
         }, {
           onError: (error, stackTrace) => {
             if (stackTrace === void 0)
               stackTrace = null;
             dart.assert(target[_isChained]);
             target[_completeError](error, dart.as(stackTrace, core.StackTrace));
           }
         });
       }
       static _chainCoreFuture(source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
-        dart.assert(dart.is(source, _Future));
+        dart.assert(dart.is(source, _Future$()));
         target[_isChained] = true;
         let listener = new _FutureListener.chain(target);
         if (source[_isComplete]) {
           _Future._propagateToListeners(source, listener);
         } else {
           source[_addListener](listener);
         }
       }
       [_complete](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         if (dart.is(value, Future)) {
-          if (dart.is(value, _Future)) {
-            _Future._chainCoreFuture(dart.as(value, _Future), this);
+          if (dart.is(value, _Future$())) {
+            _Future._chainCoreFuture(dart.as(value, _Future$()), this);
           } else {
             _Future._chainForeignFuture(dart.as(value, Future), this);
           }
         } else {
           let listeners = this[_removeListeners]();
           this[_setValue](dart.as(value, T));
           _Future._propagateToListeners(this, listeners);
         }
       }
       [_completeWithValue](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         dart.assert(!dart.is(value, Future));
         let listeners = this[_removeListeners]();
         this[_setValue](dart.as(value, T));
         _Future._propagateToListeners(this, listeners);
       }
       [_completeError](error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         dart.assert(!dart.notNull(this[_isComplete]));
         let listeners = this[_removeListeners]();
         this[_setError](error, stackTrace);
         _Future._propagateToListeners(this, listeners);
       }
       [_asyncComplete](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         if (value == null) {
         } else if (dart.is(value, Future)) {
           let typedFuture = dart.as(value, Future$(T));
-          if (dart.is(typedFuture, _Future)) {
+          if (dart.is(typedFuture, _Future$())) {
             let coreFuture = dart.as(typedFuture, _Future$(T));
             if (dart.notNull(coreFuture[_isComplete]) && dart.notNull(coreFuture[_hasError])) {
               this[_markPendingCompletion]();
               this[_zone].scheduleMicrotask((() => {
                 _Future._chainCoreFuture(coreFuture, this);
               }).bind(this));
             } else {
               _Future._chainCoreFuture(coreFuture, this);
             }
           } else {
@@ skipping 116 matching lines @@
               if (dart.is(completeResult, Future)) {
                 let result = listener.result;
                 result[_isChained] = true;
                 isPropagationAborted = true;
                 dart.dsend(completeResult, 'then', ignored => {
                   _Future._propagateToListeners(source, new _FutureListener.chain(result));
                 }, {
                   onError: (error, stackTrace) => {
                     if (stackTrace === void 0)
                       stackTrace = null;
-                    if (!dart.is(completeResult, _Future)) {
-                      completeResult = new _Future();
+                    if (!dart.is(completeResult, _Future$())) {
+                      completeResult = new (_Future$())();
                       dart.dsend(completeResult, _setError, error, stackTrace);
                     }
-                    _Future._propagateToListeners(dart.as(completeResult, _Future), new _FutureListener.chain(result));
+                    _Future._propagateToListeners(dart.as(completeResult, _Future$()), new _FutureListener.chain(result));
                   }
                 });
               }
             };
             if (!dart.notNull(hasError)) {
               if (listener.handlesValue) {
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
             if (listener.handlesComplete) {
               handleWhenCompleteCallback();
             }
             if (oldZone != null)
               Zone._leave(oldZone);
             if (isPropagationAborted)
               return;
             if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(sourceValue, listenerValueOrError)) && dart.is(listenerValueOrError, Future)) {
               let chainSource = dart.as(listenerValueOrError, Future);
               let result = listener.result;
-              if (dart.is(chainSource, _Future)) {
+              if (dart.is(chainSource, _Future$())) {
                 if (chainSource[_isComplete]) {
                   result[_isChained] = true;
                   source = chainSource;
                   listeners = new _FutureListener.chain(result);
                   continue;
                 } else {
                   _Future._chainCoreFuture(chainSource, result);
                 }
               } else {
                 _Future._chainForeignFuture(chainSource, result);
               }
               return;
             }
           }
           let result = listener.result;
           listeners = result[_removeListeners]();
           if (listenerHasValue) {
             result[_setValue](listenerValueOrError);
           } else {
             let asyncError = dart.as(listenerValueOrError, AsyncError);
             result[_setErrorObject](asyncError);
           }
           source = result;
         }
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         dart.as(onTimeout, dart.functionType(dart.dynamic, []));
         if (this[_isComplete])
-          return new _Future.immediate(this);
-        let result = new _Future();
+          return new (_Future$()).immediate(this);
+        let result = new (_Future$())();
         let timer = null;
         if (onTimeout == null) {
           timer = new Timer(timeLimit, () => {
             result[_completeError](new TimeoutException("Future not completed", timeLimit));
           });
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
           timer = new Timer(timeLimit, () => {
             try {
@@ skipping 2835 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async, core, _internal, _js_helper, _isolate_helper, collection);