rename dart_runtime.js helpers

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.dinvokef(errorHandler, error, stackTrace);
+      return dart.dcall(errorHandler, error, stackTrace);
     } else {
-      return dart.dinvokef(errorHandler, error);
+      return dart.dcall(errorHandler, error);
     }
   }
   // Function _registerErrorHandler: (Function, Zone) → Function
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return zone.registerBinaryCallback(errorHandler);
     } else {
       return zone.registerUnaryCallback(dart.as(errorHandler, dart.functionType(dart.dynamic, [dart.dynamic])));
     }
   }
@@ skipping 144 matching lines @@
             try {
               newValue = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (dart.is(newValue, Future)) {
               subscription.pause();
-              dart.dinvoke(dart.dinvoke(newValue, 'then', add, {onError: addError}), 'whenComplete', subscription.resume);
+              dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', subscription.resume);
             } else {
               controller.add(newValue);
             }
           }, {onError: dart.as(addError, core.Function), onDone: controller.close});
         }
         if (this.isBroadcast) {
           controller = new StreamController.broadcast({
             onListen: onListen,
             onCancel: () => {
               subscription.cancel();
@@ skipping 109 matching lines @@
           },
           cancelOnError: true
         });
         return result;
       }
       fold(initialValue, combine) {
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
         subscription = this.listen(element => {
-          _runUserCode(() => dart.dinvokef(combine, value, element), newValue => {
+          _runUserCode(() => dart.dcall(combine, value, element), newValue => {
             value = newValue;
           }, dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
         }, {
           onError: (e, st) => {
             result[_completeError](e, dart.as(st, core.StackTrace));
           },
           onDone: () => {
             result[_complete](value);
           },
           cancelOnError: true
@@ skipping 399 matching lines @@
         function onData(event) {
           timer.cancel();
           controller.add(event);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         // Function onError: (dynamic, StackTrace) → void
         function onError(error, stackTrace) {
           timer.cancel();
           dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
           let eventSink = controller;
-          dart.dinvoke(eventSink, '_addError', error, stackTrace);
+          dart.dsend(eventSink, '_addError', error, stackTrace);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         // Function onDone: () → void
         function onDone() {
           timer.cancel();
           controller.close();
         }
         // Function onListen: () → void
         function onListen() {
           zone = Zone.current;
@@ skipping 407 matching lines @@
         if (dart.is(this[_cancelFuture], Future)) {
           this[_cancelFuture].whenComplete(sendDone);
         } else {
           sendDone();
         }
       }
       [_guardCallback](callback) {
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
-        dart.dinvokef(callback);
+        dart.dcall(callback);
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         this[_checkState](wasInputPaused);
       }
       [_checkState](wasInputPaused) {
         dart.assert(!dart.notNull(this[_inCallback]));
         if (dart.notNull(this[_hasPending]) && dart.notNull(this[_pending].isEmpty)) {
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_HAS_PENDING]);
           if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResumeInput])) {
             this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
           }
@@ skipping 589 matching lines @@
         let error = null;
         let stackTrace = null;
         // Function handleError: (dynamic, dynamic) → void
         function 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(() => {
-                    dart.dinvokef(cleanUp, value);
+                    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(() => {
-                  dart.dinvokef(cleanUp, value);
+                  dart.dcall(cleanUp, value);
                 });
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result[_completeError](error, stackTrace);
               }
             }
           }, {onError: handleError});
         }
         if (remaining == 0) {
           return dart.as(new Future.value(/* Unimplemented const */new core.List.from([])), Future$(core.List));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         let iterator = input[core.$iterator];
         return Future.doWhile(() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
-          return new Future.sync(() => dart.dinvokef(f, iterator.current)).then(_ => true);
+          return new Future.sync(() => dart.dcall(f, iterator.current)).then(_ => true);
         });
       }
       static doWhile(f) {
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback(keepGoing => {
           if (keepGoing) {
             new Future.sync(f).then(dart.as(nextIteration, dart.functionType(dart.dynamic, [dart.dynamic])), {onError: doneSignal[_completeError]});
           } else {
             doneSignal[_complete](null);
           }
         }, {runGuarded: true});
-        dart.dinvokef(nextIteration, true);
+        dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
     dart.defineLazyProperties(Future, {
       get _nullFuture() {
@@ skipping 526 matching lines @@
                   listenerValueOrError = new AsyncError(e, s);
                 }
                 listenerHasValue = false;
                 return;
               }
 
               if (dart.is(completeResult, Future)) {
                 let result = listener.result;
                 result[_isChained] = true;
                 isPropagationAborted = true;
-                dart.dinvoke(completeResult, 'then', ignored => {
+                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();
-                      dart.dinvoke(completeResult, '_setError', error, stackTrace);
+                      dart.dsend(completeResult, '_setError', error, stackTrace);
                     }
                     _Future[_propagateToListeners](dart.as(completeResult, _Future), new _FutureListener.chain(result));
                   }
                 });
               }
             }
             if (!dart.notNull(hasError)) {
               if (listener.handlesValue) {
                 listenerHasValue = handleValueCallback();
               }
@@ skipping 160 matching lines @@
     }
     Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
   }
   let _initializeScheduleImmediate = Symbol('_initializeScheduleImmediate');
   let _scheduleImmediateJsOverride = Symbol('_scheduleImmediateJsOverride');
   let _scheduleImmediateWithSetImmediate = Symbol('_scheduleImmediateWithSetImmediate');
   let _scheduleImmediateWithTimer = Symbol('_scheduleImmediateWithTimer');
   let _createTimer = Symbol('_createTimer');
   class _AsyncRun extends core.Object {
     static [_scheduleImmediate](callback) {
-      dart.dinvokef(_AsyncRun.scheduleImmediateClosure, callback);
+      dart.dcall(_AsyncRun.scheduleImmediateClosure, callback);
     }
     static [_initializeScheduleImmediate]() {
       _js_helper.requiresPreamble();
       if (self.scheduleImmediate != null) {
         return _AsyncRun[_scheduleImmediateJsOverride];
       }
       if (dart.notNull(self.MutationObserver != null) && dart.notNull(self.document != null)) {
         let div = self.document.createElement("div");
         let span = self.document.createElement("span");
         let storedCallback = null;
         // Function internalCallback: (dynamic) → dynamic
         function internalCallback(_) {
           _isolate_helper.leaveJsAsync();
           let f = storedCallback;
           storedCallback = null;
-          dart.dinvokef(f);
+          dart.dcall(f);
         }
         ;
         let observer = new self.MutationObserver(_js_helper.convertDartClosureToJS(internalCallback, 1));
         observer.observe(div, {childList: true});
         return callback => {
           dart.assert(storedCallback == null);
           _isolate_helper.enterJsAsync();
           storedCallback = callback;
           div.firstChild ? div.removeChild(span) : div.appendChild(span);
         };
@@ skipping 1096 matching lines @@
     _StreamIteratorImpl._STATE_MOVING = 2;
     _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
     _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
     _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
     return _StreamIteratorImpl;
   });
   let _StreamIteratorImpl = _StreamIteratorImpl$();
   // Function _runUserCode: (() → dynamic, (dynamic) → dynamic, (dynamic, StackTrace) → dynamic) → dynamic
   function _runUserCode(userCode, onSuccess, onError) {
     try {
-      dart.dinvokef(onSuccess, userCode());
+      dart.dcall(onSuccess, userCode());
     } catch (e) {
       let s = dart.stackTrace(e);
       let replacement = Zone.current.errorCallback(e, s);
       if (replacement == null) {
-        dart.dinvokef(onError, e, s);
+        dart.dcall(onError, e, s);
       } else {
         let error = _nonNullError(replacement.error);
         let stackTrace = replacement.stackTrace;
-        dart.dinvokef(onError, error, stackTrace);
+        dart.dcall(onError, error, stackTrace);
       }
     }
 
   }
   // Function _cancelAndError: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic, StackTrace) → void
   function _cancelAndError(subscription, future, error, stackTrace) {
     let cancelFuture = subscription.cancel();
     if (dart.is(cancelFuture, Future)) {
       cancelFuture.whenComplete(() => future[_completeError](error, stackTrace));
     } else {
@@ skipping 154 matching lines @@
   let _transform = Symbol('_transform');
   let _MapStream$ = dart.generic(function(S, T) {
     class _MapStream extends _ForwardingStream$(S, T) {
       _MapStream(source, transform) {
         this[_transform] = transform;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         let outputEvent = null;
         try {
-          outputEvent = dart.as(dart.dinvokef(this[_transform], inputEvent), T);
+          outputEvent = dart.as(dart.dcall(this[_transform], inputEvent), T);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         sink[_add](outputEvent);
       }
     }
     return _MapStream;
@@ skipping 26 matching lines @@
     class _HandleErrorStream extends _ForwardingStream$(T, T) {
       _HandleErrorStream(source, onError, test) {
         this[_transform] = onError;
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleError](error, stackTrace, sink) {
         let matches = true;
         if (this[_test] != null) {
           try {
-            matches = dart.dinvokef(this[_test], error);
+            matches = dart.dcall(this[_test], error);
           } catch (e) {
             let s = dart.stackTrace(e);
             _addErrorWithReplacement(sink, e, s);
             return;
           }
 
         }
         if (matches) {
           try {
             _invokeErrorHandler(this[_transform], error, stackTrace);
@@ skipping 575 matching lines @@
   let _scheduleMicrotask = Symbol('_scheduleMicrotask');
   let _print = Symbol('_print');
   let _fork = Symbol('_fork');
   class _ZoneDelegate extends core.Object {
     _ZoneDelegate(delegationTarget) {
       this[_delegationTarget] = delegationTarget;
     }
     handleUncaughtError(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_handleUncaughtError];
       let implZone = implementation.zone;
-      return dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace);
+      return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace);
     }
     run(zone, f) {
       let implementation = this[_delegationTarget][_run];
       let implZone = implementation.zone;
-      return dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f);
+      return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f);
     }
     runUnary(zone, f, arg) {
       let implementation = this[_delegationTarget][_runUnary];
       let implZone = implementation.zone;
-      return dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f, arg);
+      return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f, arg);
     }
     runBinary(zone, f, arg1, arg2) {
       let implementation = this[_delegationTarget][_runBinary];
       let implZone = implementation.zone;
-      return dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f, arg1, arg2);
+      return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f, arg1, arg2);
     }
     registerCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneCallback);
+      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneCallback);
     }
     registerUnaryCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerUnaryCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneUnaryCallback);
+      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneUnaryCallback);
     }
     registerBinaryCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerBinaryCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneBinaryCallback);
+      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneBinaryCallback);
     }
     errorCallback(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_errorCallback];
       let implZone = implementation.zone;
       if (core.identical(implZone, _ROOT_ZONE))
         return null;
-      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace), AsyncError);
+      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(zone, f) {
       let implementation = this[_delegationTarget][_scheduleMicrotask];
       let implZone = implementation.zone;
-      dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f);
+      dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f);
     }
     createTimer(zone, duration, f) {
       let implementation = this[_delegationTarget][_createTimer];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, duration, f), Timer);
+      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, duration, f), Timer);
     }
     createPeriodicTimer(zone, period, f) {
       let implementation = this[_delegationTarget][_createPeriodicTimer];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, period, f), Timer);
+      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, period, f), Timer);
     }
     print(zone, line) {
       let implementation = this[_delegationTarget][_print];
       let implZone = implementation.zone;
-      dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, line);
+      dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, line);
     }
     fork(zone, specification, zoneValues) {
       let implementation = this[_delegationTarget][_fork];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
+      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
     }
   }
   _ZoneDelegate[dart.implements] = () => [ZoneDelegate];
   class _Zone extends core.Object {
     _Zone() {
     }
     inSameErrorZone(otherZone) {
       return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
     }
   }
@@ skipping 107 matching lines @@
         }
         return value;
       }
       dart.assert(dart.equals(this, _ROOT_ZONE));
       return null;
     }
     handleUncaughtError(error, stackTrace) {
       let implementation = this[_handleUncaughtError];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, error, stackTrace);
+      return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, error, stackTrace);
     }
     fork(opts) {
       let specification = opts && 'specification' in opts ? opts.specification : null;
       let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
       let implementation = this[_fork];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, specification, zoneValues), Zone);
+      return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, specification, zoneValues), Zone);
     }
     run(f) {
       let implementation = this[_run];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f);
+      return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f);
     }
     runUnary(f, arg) {
       let implementation = this[_runUnary];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f, arg);
+      return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f, arg);
     }
     runBinary(f, arg1, arg2) {
       let implementation = this[_runBinary];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f, arg1, arg2);
+      return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f, arg1, arg2);
     }
     registerCallback(f) {
       let implementation = this[_registerCallback];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f), ZoneCallback);
+      return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f), ZoneCallback);
     }
     registerUnaryCallback(f) {
       let implementation = this[_registerUnaryCallback];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f), ZoneUnaryCallback);
+      return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f), ZoneUnaryCallback);
     }
     registerBinaryCallback(f) {
       let implementation = this[_registerBinaryCallback];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f), ZoneBinaryCallback);
+      return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f), ZoneBinaryCallback);
     }
     errorCallback(error, stackTrace) {
       let implementation = this[_errorCallback];
       dart.assert(implementation != null);
       let implementationZone = implementation.zone;
       if (core.identical(implementationZone, _ROOT_ZONE))
         return null;
       let parentDelegate = _parentDelegate(dart.as(implementationZone, _Zone));
-      return dart.as(dart.dinvokef(implementation.function, implementationZone, parentDelegate, this, error, stackTrace), AsyncError);
+      return dart.as(dart.dcall(implementation.function, implementationZone, parentDelegate, this, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(f) {
       let implementation = this[_scheduleMicrotask];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f);
+      return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f);
     }
     createTimer(duration, f) {
       let implementation = this[_createTimer];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, duration, f), Timer);
+      return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, duration, f), Timer);
     }
     createPeriodicTimer(duration, f) {
       let implementation = this[_createPeriodicTimer];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, duration, f), Timer);
+      return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, duration, f), Timer);
     }
     print(line) {
       let implementation = this[_print];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, line);
+      return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, line);
     }
   }
   // Function _rootHandleUncaughtError: (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → void
   function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
     _schedulePriorityAsyncCallback(() => {
       throw new _UncaughtAsyncError(error, stackTrace);
     });
   }
   // Function _rootRun: (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic
   function _rootRun(self, parent, zone, f) {
     if (dart.equals(Zone[_current], zone))
       return f();
     let old = Zone[_enter](zone);
     try {
       return f();
     } finally {
       Zone[_leave](old);
     }
   }
   // Function _rootRunUnary: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic
   function _rootRunUnary(self, parent, zone, f, arg) {
     if (dart.equals(Zone[_current], zone))
-      return dart.dinvokef(f, arg);
+      return dart.dcall(f, arg);
     let old = Zone[_enter](zone);
     try {
-      return dart.dinvokef(f, arg);
+      return dart.dcall(f, arg);
     } finally {
       Zone[_leave](old);
     }
   }
   // Function _rootRunBinary: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic
   function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
     if (dart.equals(Zone[_current], zone))
-      return dart.dinvokef(f, arg1, arg2);
+      return dart.dcall(f, arg1, arg2);
     let old = Zone[_enter](zone);
     try {
-      return dart.dinvokef(f, arg1, arg2);
+      return dart.dcall(f, arg1, arg2);
     } finally {
       Zone[_leave](old);
     }
   }
   // Function _rootRegisterCallback: (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback
   function _rootRegisterCallback(self, parent, zone, f) {
     return f;
   }
   // Function _rootRegisterUnaryCallback: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → ZoneUnaryCallback
   function _rootRegisterUnaryCallback(self, parent, zone, f) {
@@ skipping 166 matching lines @@
         return _rootRun(null, null, this, f);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runUnaryGuarded(f, arg) {
       try {
         if (core.identical(_ROOT_ZONE, Zone[_current])) {
-          return dart.dinvokef(f, arg);
+          return dart.dcall(f, arg);
         }
         return _rootRunUnary(null, null, this, f, arg);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runBinaryGuarded(f, arg1, arg2) {
       try {
         if (core.identical(_ROOT_ZONE, Zone[_current])) {
-          return dart.dinvokef(f, arg1, arg2);
+          return dart.dcall(f, arg1, arg2);
         }
         return _rootRunBinary(null, null, this, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
@@ skipping 30 matching lines @@
       let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
       return _rootFork(null, null, this, specification, zoneValues);
     }
     run(f) {
       if (core.identical(Zone[_current], _ROOT_ZONE))
         return f();
       return _rootRun(null, null, this, f);
     }
     runUnary(f, arg) {
       if (core.identical(Zone[_current], _ROOT_ZONE))
-        return dart.dinvokef(f, arg);
+        return dart.dcall(f, arg);
       return _rootRunUnary(null, null, this, f, arg);
     }
     runBinary(f, arg1, arg2) {
       if (core.identical(Zone[_current], _ROOT_ZONE))
-        return dart.dinvokef(f, arg1, arg2);
+        return dart.dcall(f, arg1, arg2);
       return _rootRunBinary(null, null, this, f, arg1, arg2);
     }
     registerCallback(f) {
       return f;
     }
     registerUnaryCallback(f) {
       return f;
     }
     registerBinaryCallback(f) {
       return f;
@@ skipping 106 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 = {}));