fixes #158, precendence of call and access in new

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dcall(errorHandler, error, stackTrace);
     } else {
       return dart.dcall(errorHandler, error);
     }
@@ skipping 1756 matching lines @@
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         });
         return dart.as(result, Future$(T));
       }
       sync(computation) {
         try {
           let result = computation();
-          return new Future$(T).value(result);
+          return new (Future$(T)).value(result);
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
-          return new Future$(T).error(error, stackTrace);
+          return new (Future$(T)).error(error, stackTrace);
         }
 
       }
       value(value) {
         if (value === void 0)
           value = null;
-        return new _Future$(T).immediate(value);
+        return new (_Future$(T)).immediate(value);
       }
       error(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(core.identical(Zone.current, _ROOT_ZONE))) {
           let replacement = Zone.current.errorCallback(error, stackTrace);
           if (replacement != null) {
             error = _nonNullError(replacement.error);
             stackTrace = replacement.stackTrace;
           }
         }
-        return new _Future$(T).immediateError(error, stackTrace);
+        return new (_Future$(T)).immediateError(error, stackTrace);
       }
       delayed(duration, computation) {
         if (computation === void 0)
           computation = null;
         let result = new (_Future$(T))();
         new Timer(duration, () => {
           try {
             result[_complete](computation == null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
@@ skipping 52 matching lines @@
                   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([]));
+          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;
@@ skipping 307 matching lines @@
       whenComplete(action) {
         dart.as(action, dart.functionType(dart.dynamic, []));
         let result = new (_Future$(T))();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           action = result[_zone].registerCallback(action);
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
         return dart.as(result, Future$(T));
       }
       asStream() {
-        return new Stream$(T).fromFuture(this);
+        return new (Stream$(T)).fromFuture(this);
       }
       [_markPendingCompletion]() {
         if (!dart.notNull(this[_mayComplete]))
           throw new core.StateError("Future already completed");
         this[_state] = _Future._PENDING_COMPLETE;
       }
       get [_value]() {
         dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasValue]));
         return dart.as(this[_resultOrListeners], T);
       }
@@ skipping 1471 matching lines @@
         this[_current] = null;
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl._STATE_FOUND;
         this[_subscription] = stream.listen(this[_onData].bind(this), {onError: this[_onError].bind(this), onDone: this[_onDone].bind(this), cancelOnError: true});
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (this[_state] == _StreamIteratorImpl._STATE_DONE) {
-          return new _Future$(core.bool).immediate(false);
+          return new (_Future$(core.bool)).immediate(false);
         }
         if (this[_state] == _StreamIteratorImpl._STATE_MOVING) {
           throw new core.StateError("Already waiting for next.");
         }
         if (this[_state] == _StreamIteratorImpl._STATE_FOUND) {
           this[_state] = _StreamIteratorImpl._STATE_MOVING;
           this[_current] = null;
           this[_futureOrPrefetch] = new (_Future$(core.bool))();
           return dart.as(this[_futureOrPrefetch], Future$(core.bool));
         } else {
           dart.assert(dart.notNull(this[_state]) >= dart.notNull(_StreamIteratorImpl._STATE_EXTRA_DATA));
           switch (this[_state]) {
             case _StreamIteratorImpl._STATE_EXTRA_DATA:
             {
               this[_state] = _StreamIteratorImpl._STATE_FOUND;
               this[_current] = dart.as(this[_futureOrPrefetch], T);
               this[_futureOrPrefetch] = null;
               this[_subscription].resume();
-              return new _Future$(core.bool).immediate(true);
+              return new (_Future$(core.bool)).immediate(true);
             }
             case _StreamIteratorImpl._STATE_EXTRA_ERROR:
             {
               let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
               this[_clear]();
-              return new _Future$(core.bool).immediateError(prefetch.error, prefetch.stackTrace);
+              return new (_Future$(core.bool)).immediateError(prefetch.error, prefetch.stackTrace);
             }
             case _StreamIteratorImpl._STATE_EXTRA_DONE:
             {
               this[_clear]();
-              return new _Future$(core.bool).immediate(false);
+              return new (_Future$(core.bool)).immediate(false);
             }
           }
         }
       }
       [_clear]() {
         this[_subscription] = null;
         this[_futureOrPrefetch] = null;
         this[_current] = null;
         this[_state] = _StreamIteratorImpl._STATE_DONE;
       }
@@ skipping 1634 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 || (async = {}));