Rewire DDC to use the analyzer task model

lib/runtime/dart/async.js

 dart_library.library('dart/async', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/_internal',
   'dart/collection'
 ], /* Lazy imports */[
   'dart/_isolate_helper'
 ], function(exports, dart, core, _internal, collection, _isolate_helper) {
   'use strict';
   let dartx = dart.dartx;
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dcall(errorHandler, error, stackTrace);
     } else {
       return dart.dcall(errorHandler, error);
     }
   }
   dart.fn(_invokeErrorHandler, dart.dynamic, [core.Function, core.Object, core.StackTrace]);
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
-      return zone.registerBinaryCallback(errorHandler);
+      return dart.dcall(zone.registerBinaryCallback, errorHandler);
     } else {
-      return zone.registerUnaryCallback(dart.as(errorHandler, __CastType0));
+      return dart.dcall(zone.registerUnaryCallback, errorHandler);
     }
   }
   dart.fn(_registerErrorHandler, () => dart.definiteFunctionType(core.Function, [core.Function, Zone]));
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
-      return dart.toString(this.error);
+      return dart.as(dart.dsend(this.error, 'toString'), core.String);
     }
   }
   AsyncError[dart.implements] = () => [core.Error];
   dart.setSignature(AsyncError, {
     constructors: () => ({AsyncError: [AsyncError, [dart.dynamic, core.StackTrace]]})
   });
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
-      super.AsyncError(error, _UncaughtAsyncError._getBestStackTrace(error, stackTrace));
+      super.AsyncError(error, dart.dcall(_UncaughtAsyncError._getBestStackTrace, error, stackTrace));
     }
     static _getBestStackTrace(error, stackTrace) {
       if (stackTrace != null)
         return stackTrace;
       if (dart.is(error, core.Error)) {
         return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
       }
       return null;
     }
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace != null) {
         result = dart.notNull(result) + `\nStack Trace:\n${this.stackTrace}`;
       }
       return result;
     }
   }
   dart.setSignature(_UncaughtAsyncError, {
     constructors: () => ({_UncaughtAsyncError: [_UncaughtAsyncError, [dart.dynamic, core.StackTrace]]}),
     statics: () => ({_getBestStackTrace: [core.StackTrace, [dart.dynamic, core.StackTrace]]}),
     names: ['_getBestStackTrace']
   });
-  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let _add = Symbol('_add');
   let _closeUnchecked = Symbol('_closeUnchecked');
   let _addError = Symbol('_addError');
   let _completeError = Symbol('_completeError');
   let _complete = Symbol('_complete');
   let _sink = Symbol('_sink');
   let Stream$ = dart.generic(function(T) {
     class Stream extends core.Object {
       Stream() {
       }
       static fromFuture(future) {
         let controller = dart.as(StreamController$(T).new({sync: true}), _StreamController$(T));
-        future.then(dart.fn(value => {
-          controller[_add](dart.as(value, T));
-          controller[_closeUnchecked]();
+        dart.dcall(future.then, dart.fn(value => {
+          dart.dcall(controller[_add], value);
+          dart.dcall(controller[_closeUnchecked]);
         }), {onError: dart.fn((error, stackTrace) => {
-            controller[_addError](error, dart.as(stackTrace, core.StackTrace));
-            controller[_closeUnchecked]();
+            dart.dcall(controller[_addError], error, stackTrace);
+            dart.dcall(controller[_closeUnchecked]);
           })});
         return controller.stream;
       }
       static fromIterable(data) {
         return new (_GeneratedStreamImpl$(T))(dart.fn(() => new (_IterablePendingEvents$(T))(data), _IterablePendingEvents$(T), []));
       }
       static periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation == null)
           computation = dart.fn(i => null, dart.bottom, [dart.dynamic]);
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         function sendEvent() {
-          watch.reset();
+          dart.dcall(watch.reset);
           let data = computation((() => {
             let x = computationCount;
             computationCount = dart.notNull(x) + 1;
             return x;
           })());
-          controller.add(data);
+          dart.dcall(controller.add, data);
         }
         dart.fn(sendEvent, dart.void, []);
         function startPeriodicTimer() {
           dart.assert(timer == null);
           timer = Timer.periodic(period, dart.fn(timer => {
-            sendEvent();
+            dart.dcall(sendEvent);
           }, dart.dynamic, [Timer]));
         }
         dart.fn(startPeriodicTimer, dart.void, []);
         controller = StreamController$(T).new({sync: true, onListen: dart.fn(() => {
-            watch.start();
-            startPeriodicTimer();
+            dart.dcall(watch.start);
+            dart.dcall(startPeriodicTimer);
           }), onPause: dart.fn(() => {
-            timer.cancel();
+            dart.dcall(timer.cancel);
             timer = null;
-            watch.stop();
+            dart.dcall(watch.stop);
           }), onResume: dart.fn(() => {
             dart.assert(timer == null);
             let elapsed = watch.elapsed;
-            watch.start();
+            dart.dcall(watch.start);
             timer = Timer.new(period['-'](elapsed), dart.fn(() => {
               timer = null;
-              startPeriodicTimer();
-              sendEvent();
+              dart.dcall(startPeriodicTimer);
+              dart.dcall(sendEvent);
             }));
           }), onCancel: dart.fn(() => {
             if (timer != null)
-              timer.cancel();
+              dart.dcall(timer.cancel);
             timer = null;
           })});
         return controller.stream;
       }
       static eventTransformed(source, mapSink) {
         return new (_BoundSinkStream$(dart.dynamic, T))(source, dart.as(mapSink, _SinkMapper));
       }
       get isBroadcast() {
         return false;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         dart.as(onListen, dart.functionType(dart.void, [StreamSubscription$(T)]));
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription$(T)]));
-        return new (_AsBroadcastStream$(T))(this, dart.as(onListen, __CastType12), dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription])));
+        return new (_AsBroadcastStream$(T))(this, dart.as(onListen, __CastType4), dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription])));
       }
       where(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         return new (_MapStream$(T, dart.dynamic))(this, convert);
       }
       asyncMap(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         let controller = null;
         let subscription = null;
         let onListen = (function() {
           let add = dart.bind(controller, 'add');
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
-          let addError = eventSink[_addError];
-          subscription = this.listen(dart.fn(event => {
+          let addError = dart.dload(eventSink, _addError);
+          subscription = dart.dcall(this.listen, dart.fn(event => {
             dart.as(event, T);
             let newValue = null;
             try {
               newValue = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
-              controller.addError(e, s);
+              dart.dcall(controller.addError, e, s);
               return;
             }
 
             if (dart.is(newValue, Future)) {
-              subscription.pause();
+              dart.dcall(subscription.pause);
               dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', dart.bind(subscription, 'resume'));
             } else {
-              controller.add(newValue);
+              dart.dcall(controller.add, newValue);
             }
-          }, dart.dynamic, [T]), {onError: dart.as(addError, core.Function), onDone: dart.bind(controller, 'close')});
+          }, dart.dynamic, [T]), {onError: addError, onDone: dart.bind(controller, 'close')});
         }).bind(this);
         dart.fn(onListen, dart.void, []);
         if (dart.notNull(this.isBroadcast)) {
           controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
-              subscription.cancel();
+              dart.dcall(subscription.cancel);
             }), sync: true});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
-              subscription.pause();
+              dart.dcall(subscription.pause);
             }), onResume: dart.fn(() => {
-              subscription.resume();
+              dart.dcall(subscription.resume);
             }), onCancel: dart.fn(() => {
-              subscription.cancel();
+              dart.dcall(subscription.cancel);
             }), sync: true});
         }
         return controller.stream;
       }
       asyncExpand(convert) {
         dart.as(convert, dart.functionType(Stream$(), [T]));
         let controller = null;
         let subscription = null;
         let onListen = (function() {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
-          subscription = this.listen(dart.fn(event => {
+          subscription = dart.dcall(this.listen, dart.fn(event => {
             dart.as(event, T);
             let newStream = null;
             try {
               newStream = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
-              controller.addError(e, s);
+              dart.dcall(controller.addError, e, s);
               return;
             }
 
             if (newStream != null) {
-              subscription.pause();
-              controller.addStream(newStream).whenComplete(dart.bind(subscription, 'resume'));
+              dart.dcall(subscription.pause);
+              dart.dcall(dart.dcall(controller.addStream, newStream).whenComplete, dart.bind(subscription, 'resume'));
             }
-          }, dart.dynamic, [T]), {onError: dart.as(eventSink[_addError], core.Function), onDone: dart.bind(controller, 'close')});
+          }, dart.dynamic, [T]), {onError: dart.dload(eventSink, _addError), onDone: dart.bind(controller, 'close')});
         }).bind(this);
         dart.fn(onListen, dart.void, []);
         if (dart.notNull(this.isBroadcast)) {
           controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
-              subscription.cancel();
+              dart.dcall(subscription.cancel);
             }), sync: true});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
-              subscription.pause();
+              dart.dcall(subscription.pause);
             }), onResume: dart.fn(() => {
-              subscription.resume();
+              dart.dcall(subscription.resume);
             }), onCancel: dart.fn(() => {
-              subscription.cancel();
+              dart.dcall(subscription.cancel);
             }), sync: true});
         }
         return controller.stream;
       }
       handleError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
         dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         return new (_HandleErrorStream$(T))(this, onError, test);
       }
       expand(convert) {
         dart.as(convert, dart.functionType(core.Iterable, [T]));
         return new (_ExpandStream$(T, dart.dynamic))(this, convert);
       }
       pipe(streamConsumer) {
         dart.as(streamConsumer, StreamConsumer$(T));
-        return streamConsumer.addStream(this).then(dart.fn(_ => streamConsumer.close(), Future, [dart.dynamic]));
+        return dart.dcall(dart.dcall(streamConsumer.addStream, this).then, dart.fn(_ => dart.dcall(streamConsumer.close), Future, [dart.dynamic]));
       }
       transform(streamTransformer) {
         dart.as(streamTransformer, StreamTransformer$(T, dart.dynamic));
-        return streamTransformer.bind(this);
+        return dart.dcall(streamTransformer.bind, this);
       }
       reduce(combine) {
         dart.as(combine, dart.functionType(T, [T, T]));
         let result = new (_Future$(T))();
         let seenFirst = false;
         let value = null;
         let subscription = null;
-        subscription = this.listen(dart.fn(element => {
+        subscription = dart.dcall(this.listen, dart.fn(element => {
           dart.as(element, T);
           if (dart.notNull(seenFirst)) {
-            _runUserCode(dart.fn(() => combine(value, element), T, []), dart.fn(newValue => {
+            dart.dcall(_runUserCode, dart.fn(() => combine(value, element), T, []), dart.fn(newValue => {
               dart.as(newValue, T);
               value = newValue;
-            }, dart.dynamic, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
+            }, dart.dynamic, [T]), dart.dcall(_cancelAndErrorClosure, subscription, result));
           } else {
             value = element;
             seenFirst = true;
           }
         }, dart.dynamic, [T]), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
             if (!dart.notNull(seenFirst)) {
               try {
-                dart.throw(_internal.IterableElementError.noElement());
+                dart.throw(dart.dcall(_internal.IterableElementError.noElement));
               } catch (e) {
                 let s = dart.stackTrace(e);
-                _completeWithErrorCallback(result, e, s);
+                dart.dcall(_completeWithErrorCallback, result, e, s);
               }
 
             } else {
-              result[_complete](value);
+              dart.dcall(result[_complete], value);
             }
           }), cancelOnError: true});
         return result;
       }
       fold(initialValue, combine) {
         dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, T]));
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
-        subscription = this.listen(dart.fn(element => {
+        subscription = dart.dcall(this.listen, dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(dart.fn(() => dart.dcall(combine, value, element)), dart.fn(newValue => {
+          dart.dcall(_runUserCode, dart.fn(() => dart.dcall(combine, value, element)), dart.fn(newValue => {
             value = newValue;
-          }), dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+          }), dart.dcall(_cancelAndErrorClosure, subscription, result));
         }, dart.dynamic, [T]), {onError: dart.fn((e, st) => {
-            result[_completeError](e, dart.as(st, core.StackTrace));
+            dart.dcall(result[_completeError], e, st);
           }), onDone: dart.fn(() => {
-            result[_complete](value);
+            dart.dcall(result[_complete], value);
           }), cancelOnError: true});
         return result;
       }
       join(separator) {
         if (separator === void 0)
           separator = "";
         let result = new (_Future$(core.String))();
         let buffer = new core.StringBuffer();
         let subscription = null;
         let first = true;
-        subscription = this.listen(dart.fn(element => {
+        subscription = dart.dcall(this.listen, dart.fn(element => {
           dart.as(element, T);
           if (!dart.notNull(first)) {
-            buffer.write(separator);
+            dart.dcall(buffer.write, separator);
           }
           first = false;
           try {
-            buffer.write(element);
+            dart.dcall(buffer.write, element);
           } catch (e) {
             let s = dart.stackTrace(e);
-            _cancelAndErrorWithReplacement(subscription, result, e, s);
+            dart.dcall(_cancelAndErrorWithReplacement, subscription, result, e, s);
           }
 
         }, dart.dynamic, [T]), {onError: dart.fn(e => {
-            result[_completeError](e);
+            dart.dcall(result[_completeError], e);
           }), onDone: dart.fn(() => {
-            result[_complete](dart.toString(buffer));
+            dart.dcall(result[_complete], dart.dcall(buffer.toString));
           }), cancelOnError: true});
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(dart.fn(element => {
+        subscription = dart.dcall(this.listen, dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(dart.fn(() => dart.equals(element, needle), core.bool, []), dart.fn(isMatch => {
+          dart.dcall(_runUserCode, dart.fn(() => dart.equals(element, needle), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
-              _cancelAndValue(subscription, future, true);
+              dart.dcall(_cancelAndValue, subscription, future, true);
             }
-          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+          }, dart.dynamic, [core.bool]), dart.dcall(_cancelAndErrorClosure, subscription, future));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            future[_complete](false);
+            dart.dcall(future[_complete], false);
           }), cancelOnError: true});
         return future;
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [T]));
         let future = new _Future();
         let subscription = null;
-        subscription = this.listen(dart.fn(element => {
+        subscription = dart.dcall(this.listen, dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(dart.fn(() => action(element), dart.void, []), dart.fn(_ => {
-          }), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+          dart.dcall(_runUserCode, dart.fn(() => action(element), dart.void, []), dart.fn(_ => {
+          }), dart.dcall(_cancelAndErrorClosure, subscription, future));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            future[_complete](null);
+            dart.dcall(future[_complete], null);
           }), cancelOnError: true});
         return future;
       }
       every(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(dart.fn(element => {
+        subscription = dart.dcall(this.listen, dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
+          dart.dcall(_runUserCode, dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
             if (!dart.notNull(isMatch)) {
-              _cancelAndValue(subscription, future, false);
+              dart.dcall(_cancelAndValue, subscription, future, false);
             }
-          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+          }, dart.dynamic, [core.bool]), dart.dcall(_cancelAndErrorClosure, subscription, future));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            future[_complete](true);
+            dart.dcall(future[_complete], true);
           }), cancelOnError: true});
         return future;
       }
       any(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(dart.fn(element => {
+        subscription = dart.dcall(this.listen, dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
+          dart.dcall(_runUserCode, dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
-              _cancelAndValue(subscription, future, true);
+              dart.dcall(_cancelAndValue, subscription, future, true);
             }
-          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+          }, dart.dynamic, [core.bool]), dart.dcall(_cancelAndErrorClosure, subscription, future));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            future[_complete](false);
+            dart.dcall(future[_complete], false);
           }), cancelOnError: true});
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
-        this.listen(dart.fn(_ => {
+        dart.dcall(this.listen, dart.fn(_ => {
           count = dart.notNull(count) + 1;
         }), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            future[_complete](count);
+            dart.dcall(future[_complete], count);
           }), cancelOnError: true});
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(dart.fn(_ => {
-          _cancelAndValue(subscription, future, false);
+        subscription = dart.dcall(this.listen, dart.fn(_ => {
+          dart.dcall(_cancelAndValue, subscription, future, false);
         }), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            future[_complete](true);
+            dart.dcall(future[_complete], true);
           }), cancelOnError: true});
         return future;
       }
       toList() {
         let result = dart.list([], T);
         let future = new (_Future$(core.List$(T)))();
-        this.listen(dart.fn(data => {
+        dart.dcall(this.listen, dart.fn(data => {
           dart.as(data, T);
-          result[dartx.add](data);
+          dart.dcall(result[dartx.add], data);
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            future[_complete](result);
+            dart.dcall(future[_complete], result);
           }), cancelOnError: true});
         return future;
       }
       toSet() {
         let result = core.Set$(T).new();
         let future = new (_Future$(core.Set$(T)))();
-        this.listen(dart.fn(data => {
+        dart.dcall(this.listen, dart.fn(data => {
           dart.as(data, T);
-          result.add(data);
+          dart.dcall(result.add, data);
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            future[_complete](result);
+            dart.dcall(future[_complete], result);
           }), cancelOnError: true});
         return future;
       }
       drain(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
-        return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
+        return dart.dcall(dart.dcall(this.listen, null, {cancelOnError: true}).asFuture, futureValue);
       }
       take(count) {
         return new (_TakeStream$(T))(this, count);
       }
       takeWhile(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         return new (_TakeWhileStream$(T))(this, test);
       }
       skip(count) {
         return new (_SkipStream$(T))(this, count);
       }
       skipWhile(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         return new (_SkipWhileStream$(T))(this, test);
       }
       distinct(equals) {
         if (equals === void 0)
           equals = null;
         dart.as(equals, dart.functionType(core.bool, [T, T]));
         return new (_DistinctStream$(T))(this, equals);
       }
       get first() {
         let future = new (_Future$(T))();
         let subscription = null;
-        subscription = this.listen(dart.fn(value => {
+        subscription = dart.dcall(this.listen, dart.fn(value => {
           dart.as(value, T);
-          _cancelAndValue(subscription, future, value);
+          dart.dcall(_cancelAndValue, subscription, future, value);
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             try {
-              dart.throw(_internal.IterableElementError.noElement());
+              dart.throw(dart.dcall(_internal.IterableElementError.noElement));
             } catch (e) {
               let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
+              dart.dcall(_completeWithErrorCallback, future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       get last() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen(dart.fn(value => {
+        subscription = dart.dcall(this.listen, dart.fn(value => {
           dart.as(value, T);
           foundResult = true;
           result = value;
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
-              future[_complete](result);
+              dart.dcall(future[_complete], result);
               return;
             }
             try {
-              dart.throw(_internal.IterableElementError.noElement());
+              dart.throw(dart.dcall(_internal.IterableElementError.noElement));
             } catch (e) {
               let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
+              dart.dcall(_completeWithErrorCallback, future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       get single() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen(dart.fn(value => {
+        subscription = dart.dcall(this.listen, dart.fn(value => {
           dart.as(value, T);
           if (dart.notNull(foundResult)) {
             try {
-              dart.throw(_internal.IterableElementError.tooMany());
+              dart.throw(dart.dcall(_internal.IterableElementError.tooMany));
             } catch (e) {
               let s = dart.stackTrace(e);
-              _cancelAndErrorWithReplacement(subscription, future, e, s);
+              dart.dcall(_cancelAndErrorWithReplacement, subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
-              future[_complete](result);
+              dart.dcall(future[_complete], result);
               return;
             }
             try {
-              dart.throw(_internal.IterableElementError.noElement());
+              dart.throw(dart.dcall(_internal.IterableElementError.noElement));
             } catch (e) {
               let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
+              dart.dcall(_completeWithErrorCallback, future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       firstWhere(test, opts) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         dart.as(defaultValue, dart.functionType(core.Object, []));
         let future = new _Future();
         let subscription = null;
-        subscription = this.listen(dart.fn(value => {
+        subscription = dart.dcall(this.listen, dart.fn(value => {
           dart.as(value, T);
-          _runUserCode(dart.fn(() => test(value), core.bool, []), dart.fn(isMatch => {
+          dart.dcall(_runUserCode, dart.fn(() => test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
-              _cancelAndValue(subscription, future, value);
+              dart.dcall(_cancelAndValue, subscription, future, value);
             }
-          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+          }, dart.dynamic, [core.bool]), dart.dcall(_cancelAndErrorClosure, subscription, future));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (defaultValue != null) {
-              _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
+              dart.dcall(_runUserCode, defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
-              dart.throw(_internal.IterableElementError.noElement());
+              dart.throw(dart.dcall(_internal.IterableElementError.noElement));
             } catch (e) {
               let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
+              dart.dcall(_completeWithErrorCallback, future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       lastWhere(test, opts) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         dart.as(defaultValue, dart.functionType(core.Object, []));
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen(dart.fn(value => {
+        subscription = dart.dcall(this.listen, dart.fn(value => {
           dart.as(value, T);
-          _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
+          dart.dcall(_runUserCode, dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               foundResult = true;
               result = value;
             }
-          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+          }, dart.dynamic, [core.bool]), dart.dcall(_cancelAndErrorClosure, subscription, future));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
-              future[_complete](result);
+              dart.dcall(future[_complete], result);
               return;
             }
             if (defaultValue != null) {
-              _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
+              dart.dcall(_runUserCode, defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
-              dart.throw(_internal.IterableElementError.noElement());
+              dart.throw(dart.dcall(_internal.IterableElementError.noElement));
             } catch (e) {
               let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
+              dart.dcall(_completeWithErrorCallback, future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       singleWhere(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen(dart.fn(value => {
+        subscription = dart.dcall(this.listen, dart.fn(value => {
           dart.as(value, T);
-          _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
+          dart.dcall(_runUserCode, dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               if (dart.notNull(foundResult)) {
                 try {
-                  dart.throw(_internal.IterableElementError.tooMany());
+                  dart.throw(dart.dcall(_internal.IterableElementError.tooMany));
                 } catch (e) {
                   let s = dart.stackTrace(e);
-                  _cancelAndErrorWithReplacement(subscription, future, e, s);
+                  dart.dcall(_cancelAndErrorWithReplacement, subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
-          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+          }, dart.dynamic, [core.bool]), dart.dcall(_cancelAndErrorClosure, subscription, future));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
-              future[_complete](result);
+              dart.dcall(future[_complete], result);
               return;
             }
             try {
-              dart.throw(_internal.IterableElementError.noElement());
+              dart.throw(dart.dcall(_internal.IterableElementError.noElement));
             } catch (e) {
               let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
+              dart.dcall(_completeWithErrorCallback, future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       elementAt(index) {
         if (!(typeof index == 'number') || dart.notNull(index) < 0)
           dart.throw(new core.ArgumentError(index));
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
-        subscription = this.listen(dart.fn(value => {
+        subscription = dart.dcall(this.listen, dart.fn(value => {
           dart.as(value, T);
           if (index == elementIndex) {
-            _cancelAndValue(subscription, future, value);
+            dart.dcall(_cancelAndValue, subscription, future, value);
             return;
           }
           elementIndex = dart.notNull(elementIndex) + 1;
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn((() => {
-            future[_completeError](core.RangeError.index(index, this, "index", null, elementIndex));
+            dart.dcall(future[_completeError], core.RangeError.index(index, this, "index", null, elementIndex));
           }).bind(this)), cancelOnError: true});
         return future;
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         dart.as(onTimeout, dart.functionType(dart.void, [EventSink]));
         let controller = null;
         let subscription = null;
         let timer = null;
         let zone = null;
         let timeout = null;
         function onData(event) {
           dart.as(event, T);
-          timer.cancel();
-          controller.add(event);
-          timer = zone.createTimer(timeLimit, dart.as(timeout, __CastType17));
+          dart.dcall(timer.cancel);
+          dart.dcall(controller.add, event);
+          timer = dart.dcall(zone.createTimer, timeLimit, timeout);
         }
         dart.fn(onData, dart.void, [T]);
         function onError(error, stackTrace) {
-          timer.cancel();
+          dart.dcall(timer.cancel);
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
-          dart.dcall(eventSink[_addError], error, stackTrace);
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
+          dart.dsend(eventSink, _addError, error, stackTrace);
+          timer = dart.dcall(zone.createTimer, timeLimit, timeout);
         }
         dart.fn(onError, dart.void, [dart.dynamic, core.StackTrace]);
         function onDone() {
-          timer.cancel();
-          controller.close();
+          dart.dcall(timer.cancel);
+          dart.dcall(controller.close);
         }
         dart.fn(onDone, dart.void, []);
         let onListen = (function() {
           zone = Zone.current;
           if (onTimeout == null) {
             timeout = dart.fn(() => {
-              controller.addError(new TimeoutException("No stream event", timeLimit), null);
+              dart.dcall(controller.addError, new TimeoutException("No stream event", timeLimit), null);
             });
           } else {
-            onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), __CastType18);
+            onTimeout = dart.as(dart.dcall(zone.registerUnaryCallback, onTimeout), __CastType6);
             let wrapper = new _ControllerEventSinkWrapper(null);
             timeout = dart.fn(() => {
               wrapper[_sink] = controller;
-              zone.runUnaryGuarded(onTimeout, wrapper);
+              dart.dcall(zone.runUnaryGuarded, onTimeout, wrapper);
               wrapper[_sink] = null;
             });
           }
-          subscription = this.listen(onData, {onError: onError, onDone: onDone});
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
+          subscription = dart.dcall(this.listen, onData, {onError: onError, onDone: onDone});
+          timer = dart.dcall(zone.createTimer, timeLimit, timeout);
         }).bind(this);
         dart.fn(onListen, dart.void, []);
         function onCancel() {
-          timer.cancel();
-          let result = subscription.cancel();
+          dart.dcall(timer.cancel);
+          let result = dart.dcall(subscription.cancel);
           subscription = null;
           return result;
         }
         dart.fn(onCancel, Future, []);
         controller = dart.notNull(this.isBroadcast) ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, dart.fn(() => {
-          timer.cancel();
-          subscription.pause();
+          dart.dcall(timer.cancel);
+          dart.dcall(subscription.pause);
         }), dart.fn(() => {
-          subscription.resume();
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
+          dart.dcall(subscription.resume);
+          timer = dart.dcall(zone.createTimer, timeLimit, timeout);
         }), onCancel);
         return controller.stream;
       }
     }
     dart.setSignature(Stream, {
       constructors: () => ({
         Stream: [Stream$(T), []],
         fromFuture: [Stream$(T), [Future$(T)]],
         fromIterable: [Stream$(T), [core.Iterable$(T)]],
         periodic: [Stream$(T), [core.Duration], [dart.functionType(T, [core.int])]],
@@ skipping 40 matching lines @@
     class _StreamImpl extends Stream$(T) {
       _StreamImpl() {
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
-        cancelOnError = core.identical(true, cancelOnError);
-        let subscription = this[_createSubscription](onData, onError, onDone, cancelOnError);
-        this[_onListen](subscription);
+        cancelOnError = dart.dcall(core.identical, true, cancelOnError);
+        let subscription = dart.dcall(this[_createSubscription], onData, onError, onDone, cancelOnError);
+        dart.dcall(this[_onListen], subscription);
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         return new (_BufferingStreamSubscription$(T))(onData, onError, onDone, cancelOnError);
       }
       [_onListen](subscription) {}
     }
     dart.setSignature(_StreamImpl, {
       methods: () => ({
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_onListen]: [dart.void, [StreamSubscription]]
       })
     });
     return _StreamImpl;
   });
   let _StreamImpl = _StreamImpl$();
   let _controller = Symbol('_controller');
   let _subscribe = Symbol('_subscribe');
   let _ControllerStream$ = dart.generic(function(T) {
     class _ControllerStream extends _StreamImpl$(T) {
       _ControllerStream(controller) {
         this[_controller] = controller;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
-        return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
+        return dart.dcall(this[_controller][_subscribe], onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
         return dart.notNull(dart.hashCode(this[_controller])) ^ 892482866;
       }
       ['=='](other) {
-        if (dart.notNull(core.identical(this, other)))
+        if (dart.notNull(dart.dcall(core.identical, this, other)))
           return true;
         if (!dart.is(other, _ControllerStream$()))
           return false;
         let otherStream = dart.as(other, _ControllerStream$());
-        return core.identical(otherStream[_controller], this[_controller]);
+        return dart.dcall(core.identical, otherStream[_controller], this[_controller]);
       }
     }
     dart.setSignature(_ControllerStream, {
       constructors: () => ({_ControllerStream: [_ControllerStream$(T), [_StreamControllerLifecycle$(T)]]}),
       methods: () => ({
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         '==': [core.bool, [core.Object]]
       })
     });
     return _ControllerStream;
@@ skipping 57 matching lines @@
   let _BufferingStreamSubscription$ = dart.generic(function(T) {
     class _BufferingStreamSubscription extends core.Object {
       _BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
         this[_zone] = Zone.current;
         this[_state] = dart.notNull(cancelOnError) ? _BufferingStreamSubscription$()._STATE_CANCEL_ON_ERROR : 0;
         this[_onData] = null;
         this[_onError] = null;
         this[_onDone] = null;
         this[_cancelFuture] = null;
         this[_pending] = null;
-        this.onData(onData);
-        this.onError(onError);
-        this.onDone(onDone);
+        dart.dcall(this.onData, onData);
+        dart.dcall(this.onError, onError);
+        dart.dcall(this.onDone, onDone);
       }
       [_setPendingEvents](pendingEvents) {
         dart.assert(this[_pending] == null);
         if (pendingEvents == null)
           return;
         this[_pending] = pendingEvents;
         if (!dart.notNull(pendingEvents.isEmpty)) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_HAS_PENDING);
-          this[_pending].schedule(this);
+          dart.dcall(this[_pending].schedule, this);
         }
       }
       [_extractPending]() {
         dart.assert(this[_isCanceled]);
         let events = this[_pending];
         this[_pending] = null;
         return events;
       }
       onData(handleData) {
         dart.as(handleData, dart.functionType(dart.void, [T]));
         if (handleData == null)
-          handleData = dart.as(_nullDataHandler, __CastType20);
-        this[_onData] = dart.as(this[_zone].registerUnaryCallback(handleData), _DataHandler$(T));
+          handleData = dart.as(_nullDataHandler, __CastType8);
+        this[_onData] = dart.as(dart.dcall(this[_zone].registerUnaryCallback, handleData), _DataHandler$(T));
       }
       onError(handleError) {
         if (handleError == null)
           handleError = _nullErrorHandler;
-        this[_onError] = _registerErrorHandler(handleError, this[_zone]);
+        this[_onError] = dart.dcall(_registerErrorHandler, handleError, this[_zone]);
       }
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
         if (handleDone == null)
           handleDone = _nullDoneHandler;
-        this[_onDone] = this[_zone].registerCallback(handleDone);
+        this[_onDone] = dart.dcall(this[_zone].registerCallback, handleDone);
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         if (dart.notNull(this[_isCanceled]))
           return;
         let wasPaused = this[_isPaused];
         let wasInputPaused = this[_isInputPaused];
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription$()._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED);
         if (resumeSignal != null)
-          resumeSignal.whenComplete(dart.bind(this, 'resume'));
+          dart.dcall(resumeSignal.whenComplete, dart.bind(this, 'resume'));
         if (!dart.notNull(wasPaused) && this[_pending] != null)
-          this[_pending].cancelSchedule();
+          dart.dcall(this[_pending].cancelSchedule);
         if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
-          this[_guardCallback](dart.bind(this, _onPause));
+          dart.dcall(this[_guardCallback], dart.bind(this, _onPause));
       }
       resume() {
         if (dart.notNull(this[_isCanceled]))
           return;
         if (dart.notNull(this[_isPaused])) {
-          this[_decrementPauseCount]();
+          dart.dcall(this[_decrementPauseCount]);
           if (!dart.notNull(this[_isPaused])) {
             if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending].isEmpty)) {
-              this[_pending].schedule(this);
+              dart.dcall(this[_pending].schedule, this);
             } else {
               dart.assert(this[_mayResumeInput]);
               this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED);
               if (!dart.notNull(this[_inCallback]))
-                this[_guardCallback](dart.bind(this, _onResume));
+                dart.dcall(this[_guardCallback], dart.bind(this, _onResume));
             }
           }
         }
       }
       cancel() {
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
         if (dart.notNull(this[_isCanceled]))
           return this[_cancelFuture];
-        this[_cancel]();
+        dart.dcall(this[_cancel]);
         return this[_cancelFuture];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new (_Future$(T))();
         this[_onDone] = dart.fn(() => {
-          result[_complete](futureValue);
+          dart.dcall(result[_complete], futureValue);
         });
         this[_onError] = dart.fn(((error, stackTrace) => {
-          this.cancel();
-          result[_completeError](error, dart.as(stackTrace, core.StackTrace));
+          dart.dcall(this.cancel);
+          dart.dcall(result[_completeError], error, stackTrace);
         }).bind(this));
         return result;
       }
       get [_isInputPaused]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED)) != 0;
       }
       get [_isClosed]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED)) != 0;
       }
       get [_isCanceled]() {
@@ skipping 19 matching lines @@
       }
       get [_cancelOnError]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_CANCEL_ON_ERROR)) != 0;
       }
       get isPaused() {
         return this[_isPaused];
       }
       [_cancel]() {
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CANCELED);
         if (dart.notNull(this[_hasPending])) {
-          this[_pending].cancelSchedule();
+          dart.dcall(this[_pending].cancelSchedule);
         }
         if (!dart.notNull(this[_inCallback]))
           this[_pending] = null;
-        this[_cancelFuture] = this[_onCancel]();
+        this[_cancelFuture] = dart.dcall(this[_onCancel]);
       }
       [_incrementPauseCount]() {
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription$()._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED);
       }
       [_decrementPauseCount]() {
         dart.assert(this[_isPaused]);
         this[_state] = dart.notNull(this[_state]) - dart.notNull(_BufferingStreamSubscription$()._STATE_PAUSE_COUNT);
       }
       [_add](data) {
         dart.as(data, T);
         dart.assert(!dart.notNull(this[_isClosed]));
         if (dart.notNull(this[_isCanceled]))
           return;
         if (dart.notNull(this[_canFire])) {
-          this[_sendData](data);
+          dart.dcall(this[_sendData], data);
         } else {
-          this[_addPending](new _DelayedData(data));
+          dart.dcall(this[_addPending], new _DelayedData(data));
         }
       }
       [_addError](error, stackTrace) {
         if (dart.notNull(this[_isCanceled]))
           return;
         if (dart.notNull(this[_canFire])) {
-          this[_sendError](error, stackTrace);
+          dart.dcall(this[_sendError], error, stackTrace);
         } else {
-          this[_addPending](new _DelayedError(error, stackTrace));
+          dart.dcall(this[_addPending], new _DelayedError(error, stackTrace));
         }
       }
       [_close]() {
         dart.assert(!dart.notNull(this[_isClosed]));
         if (dart.notNull(this[_isCanceled]))
           return;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED);
         if (dart.notNull(this[_canFire])) {
-          this[_sendDone]();
+          dart.dcall(this[_sendDone]);
         } else {
-          this[_addPending](dart.const(new _DelayedDone()));
+          dart.dcall(this[_addPending], dart.const(new _DelayedDone()));
         }
       }
       [_onPause]() {
         dart.assert(this[_isInputPaused]);
       }
       [_onResume]() {
         dart.assert(!dart.notNull(this[_isInputPaused]));
       }
       [_onCancel]() {
         dart.assert(this[_isCanceled]);
         return null;
       }
       [_addPending](event) {
         let pending = dart.as(this[_pending], _StreamImplEvents);
         if (this[_pending] == null)
           pending = this[_pending] = new _StreamImplEvents();
-        pending.add(event);
+        dart.dcall(pending.add, event);
         if (!dart.notNull(this[_hasPending])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_HAS_PENDING);
           if (!dart.notNull(this[_isPaused])) {
-            this[_pending].schedule(this);
+            dart.dcall(this[_pending].schedule, this);
           }
         }
       }
       [_sendData](data) {
         dart.as(data, T);
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
-        this[_zone].runUnaryGuarded(this[_onData], data);
+        dart.dcall(this[_zone].runUnaryGuarded, this[_onData], data);
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
-        this[_checkState](wasInputPaused);
+        dart.dcall(this[_checkState], wasInputPaused);
       }
       [_sendError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         let sendError = (function() {
           if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           if (dart.is(this[_onError], ZoneBinaryCallback)) {
-            this[_zone].runBinaryGuarded(dart.as(this[_onError], __CastType22), error, stackTrace);
+            dart.dcall(this[_zone].runBinaryGuarded, this[_onError], error, stackTrace);
           } else {
-            this[_zone].runUnaryGuarded(dart.as(this[_onError], __CastType25), error);
+            dart.dcall(this[_zone].runUnaryGuarded, this[_onError], error);
           }
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         }).bind(this);
         dart.fn(sendError, dart.void, []);
         if (dart.notNull(this[_cancelOnError])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
-          this[_cancel]();
+          dart.dcall(this[_cancel]);
           if (dart.is(this[_cancelFuture], Future)) {
-            this[_cancelFuture].whenComplete(sendError);
+            dart.dcall(this[_cancelFuture].whenComplete, sendError);
           } else {
-            sendError();
+            dart.dcall(sendError);
           }
         } else {
-          sendError();
-          this[_checkState](wasInputPaused);
+          dart.dcall(sendError);
+          dart.dcall(this[_checkState], wasInputPaused);
         }
       }
       [_sendDone]() {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let sendDone = (function() {
           if (!dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CANCELED) | dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
-          this[_zone].runGuarded(this[_onDone]);
+          dart.dcall(this[_zone].runGuarded, this[_onDone]);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         }).bind(this);
         dart.fn(sendDone, dart.void, []);
-        this[_cancel]();
+        dart.dcall(this[_cancel]);
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
         if (dart.is(this[_cancelFuture], Future)) {
-          this[_cancelFuture].whenComplete(sendDone);
+          dart.dcall(this[_cancelFuture].whenComplete, sendDone);
         } else {
-          sendDone();
+          dart.dcall(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.dcall(callback);
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
-        this[_checkState](wasInputPaused);
+        dart.dcall(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);
           }
         }
         while (true) {
           if (dart.notNull(this[_isCanceled])) {
             this[_pending] = null;
             return;
           }
           let isInputPaused = this[_isInputPaused];
           if (wasInputPaused == isInputPaused)
             break;
           this[_state] = dart.notNull(this[_state]) ^ dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           if (dart.notNull(isInputPaused)) {
-            this[_onPause]();
+            dart.dcall(this[_onPause]);
           } else {
-            this[_onResume]();
+            dart.dcall(this[_onResume]);
           }
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           wasInputPaused = isInputPaused;
         }
         if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
-          this[_pending].schedule(this);
+          dart.dcall(this[_pending].schedule, this);
         }
       }
     }
     _BufferingStreamSubscription[dart.implements] = () => [StreamSubscription$(T), _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_BufferingStreamSubscription, {
       constructors: () => ({_BufferingStreamSubscription: [_BufferingStreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_setPendingEvents]: [dart.void, [_PendingEvents]],
         [_extractPending]: [_PendingEvents, []],
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
@@ skipping 26 matching lines @@
   let _recordCancel = Symbol('_recordCancel');
   let _recordPause = Symbol('_recordPause');
   let _recordResume = Symbol('_recordResume');
   let _ControllerSubscription$ = dart.generic(function(T) {
     class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
       _ControllerSubscription(controller, onData, onError, onDone, cancelOnError) {
         this[_controller] = controller;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
-        return this[_controller][_recordCancel](this);
+        return dart.dcall(this[_controller][_recordCancel], this);
       }
       [_onPause]() {
-        this[_controller][_recordPause](this);
+        dart.dcall(this[_controller][_recordPause], this);
       }
       [_onResume]() {
-        this[_controller][_recordResume](this);
+        dart.dcall(this[_controller][_recordResume], this);
       }
     }
     dart.setSignature(_ControllerSubscription, {
       constructors: () => ({_ControllerSubscription: [_ControllerSubscription$(T), [_StreamControllerLifecycle$(T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
     });
     return _ControllerSubscription;
   });
   let _ControllerSubscription = _ControllerSubscription$();
   let _eventState = Symbol('_eventState');
   let _expectsEvent = Symbol('_expectsEvent');
@@ skipping 83 matching lines @@
         return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_CLOSED)) != 0;
       }
       get isPaused() {
         return false;
       }
       get hasListener() {
         return !dart.notNull(this[_isEmpty]);
       }
       get [_hasOneListener]() {
         dart.assert(!dart.notNull(this[_isEmpty]));
-        return core.identical(this[_next][_next], this);
+        return dart.dcall(core.identical, this[_next][_next], this);
       }
       get [_isFiring]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_FIRING)) != 0;
       }
       get [_isAddingStream]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_ADDSTREAM)) != 0;
       }
       get [_mayAddEvent]() {
         return dart.notNull(this[_state]) < dart.notNull(_BroadcastStreamController$()._STATE_CLOSED);
       }
       [_ensureDoneFuture]() {
         if (this[_doneFuture] != null)
           return this[_doneFuture];
         return this[_doneFuture] = new _Future();
       }
       get [_isEmpty]() {
-        return core.identical(this[_next], this);
+        return dart.dcall(core.identical, this[_next], this);
       }
       [_addListener](subscription) {
         dart.as(subscription, _BroadcastSubscription$(T));
-        dart.assert(core.identical(subscription[_next], subscription));
+        dart.assert(dart.dcall(core.identical, subscription[_next], subscription));
         subscription[_previous] = this[_previous];
         subscription[_next] = this;
         this[_previous][_next] = subscription;
         this[_previous] = subscription;
         subscription[_eventState] = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID);
       }
       [_removeListener](subscription) {
         dart.as(subscription, _BroadcastSubscription$(T));
-        dart.assert(core.identical(subscription[_controller], this));
-        dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
+        dart.assert(dart.dcall(core.identical, subscription[_controller], this));
+        dart.assert(!dart.notNull(dart.dcall(core.identical, subscription[_next], subscription)));
         let previous = subscription[_previous];
         let next = subscription[_next];
         previous[_next] = next;
         next[_previous] = previous;
         subscription[_next] = subscription[_previous] = subscription;
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (dart.notNull(this.isClosed)) {
           if (onDone == null)
             onDone = _nullDoneHandler;
           return new (_DoneStreamSubscription$(T))(onDone);
         }
         let subscription = new (_BroadcastSubscription$(T))(this, onData, onError, onDone, cancelOnError);
-        this[_addListener](dart.as(subscription, _BroadcastSubscription$(T)));
-        if (dart.notNull(core.identical(this[_next], this[_previous]))) {
-          _runGuarded(this[_onListen]);
+        dart.dcall(this[_addListener], subscription);
+        if (dart.notNull(dart.dcall(core.identical, this[_next], this[_previous]))) {
+          dart.dcall(_runGuarded, this[_onListen]);
         }
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         dart.as(subscription, StreamSubscription$(T));
-        if (dart.notNull(core.identical(subscription[_next], subscription)))
+        if (dart.notNull(dart.dcall(core.identical, subscription[_next], subscription)))
           return null;
-        dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
+        dart.assert(!dart.notNull(dart.dcall(core.identical, subscription[_next], subscription)));
         if (dart.notNull(dart.as(subscription[_isFiring], core.bool))) {
           dart.dcall(subscription[_setRemoveAfterFiring]);
         } else {
-          dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
-          this[_removeListener](dart.as(subscription, _BroadcastSubscription$(T)));
+          dart.assert(!dart.notNull(dart.dcall(core.identical, subscription[_next], subscription)));
+          dart.dcall(this[_removeListener], subscription);
           if (!dart.notNull(this[_isFiring]) && dart.notNull(this[_isEmpty])) {
-            this[_callOnCancel]();
+            dart.dcall(this[_callOnCancel]);
           }
         }
         return null;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_addEventError]() {
         if (dart.notNull(this.isClosed)) {
           return new core.StateError("Cannot add new events after calling close");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add new events while doing an addStream");
       }
       add(data) {
         dart.as(data, T);
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_addEventError]());
-        this[_sendData](data);
+          dart.throw(dart.dcall(this[_addEventError]));
+        dart.dcall(this[_sendData], data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        error = _nonNullError(error);
+        error = dart.dcall(_nonNullError, error);
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_addEventError]());
-        let replacement = Zone.current.errorCallback(error, stackTrace);
+          dart.throw(dart.dcall(this[_addEventError]));
+        let replacement = dart.dcall(Zone.current.errorCallback, error, stackTrace);
         if (replacement != null) {
-          error = _nonNullError(replacement.error);
+          error = dart.dcall(_nonNullError, replacement.error);
           stackTrace = replacement.stackTrace;
         }
-        this[_sendError](error, stackTrace);
+        dart.dcall(this[_sendError], error, stackTrace);
       }
       close() {
         if (dart.notNull(this.isClosed)) {
           dart.assert(this[_doneFuture] != null);
           return this[_doneFuture];
         }
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_addEventError]());
+          dart.throw(dart.dcall(this[_addEventError]));
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController$()._STATE_CLOSED);
-        let doneFuture = this[_ensureDoneFuture]();
-        this[_sendDone]();
+        let doneFuture = dart.dcall(this[_ensureDoneFuture]);
+        dart.dcall(this[_sendDone]);
         return doneFuture;
       }
       get done() {
-        return this[_ensureDoneFuture]();
+        return dart.dcall(this[_ensureDoneFuture]);
       }
       addStream(stream, opts) {
         dart.as(stream, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_addEventError]());
+          dart.throw(dart.dcall(this[_addEventError]));
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController$()._STATE_ADDSTREAM);
         this[_addStreamState] = new (_AddStreamState$(T))(this, stream, cancelOnError);
         return this[_addStreamState].addStreamFuture;
       }
       [_add](data) {
         dart.as(data, T);
-        this[_sendData](data);
+        dart.dcall(this[_sendData], data);
       }
       [_addError](error, stackTrace) {
-        this[_sendError](error, stackTrace);
+        dart.dcall(this[_sendError], error, stackTrace);
       }
       [_close]() {
         dart.assert(this[_isAddingStream]);
         let addState = this[_addStreamState];
         this[_addStreamState] = null;
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController$()._STATE_ADDSTREAM);
-        addState.complete();
+        dart.dcall(addState.complete);
       }
       [_forEachListener](action) {
         dart.as(action, dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
         if (dart.notNull(this[_isFiring])) {
           dart.throw(new core.StateError("Cannot fire new event. Controller is already firing an event"));
         }
         if (dart.notNull(this[_isEmpty]))
           return;
         let id = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID);
         this[_state] = dart.notNull(this[_state]) ^ (dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID) | dart.notNull(_BroadcastStreamController$()._STATE_FIRING));
         let link = this[_next];
-        while (!dart.notNull(core.identical(link, this))) {
+        while (!dart.notNull(dart.dcall(core.identical, link, this))) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
-          if (dart.notNull(subscription[_expectsEvent](id))) {
+          if (dart.notNull(dart.dcall(subscription[_expectsEvent], id))) {
             subscription[_eventState] = dart.notNull(subscription[_eventState]) | dart.notNull(_BroadcastSubscription._STATE_FIRING);
             action(subscription);
-            subscription[_toggleEventId]();
+            dart.dcall(subscription[_toggleEventId]);
             link = subscription[_next];
             if (dart.notNull(subscription[_removeAfterFiring])) {
-              this[_removeListener](subscription);
+              dart.dcall(this[_removeListener], subscription);
             }
             subscription[_eventState] = dart.notNull(subscription[_eventState]) & ~dart.notNull(_BroadcastSubscription._STATE_FIRING);
           } else {
             link = subscription[_next];
           }
         }
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController$()._STATE_FIRING);
         if (dart.notNull(this[_isEmpty])) {
-          this[_callOnCancel]();
+          dart.dcall(this[_callOnCancel]);
         }
       }
       [_callOnCancel]() {
         dart.assert(this[_isEmpty]);
         if (dart.notNull(this.isClosed) && dart.notNull(this[_doneFuture][_mayComplete])) {
-          this[_doneFuture][_asyncComplete](null);
+          dart.dcall(this[_doneFuture][_asyncComplete], null);
         }
-        _runGuarded(this[_onCancel]);
+        dart.dcall(_runGuarded, this[_onCancel]);
       }
     }
     _BroadcastStreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _BroadcastSubscriptionLink, _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_BroadcastStreamController, {
       constructors: () => ({_BroadcastStreamController: [_BroadcastStreamController$(T), [_NotificationHandler, _NotificationHandler]]}),
       methods: () => ({
         [_ensureDoneFuture]: [_Future, []],
         [_addListener]: [dart.void, [_BroadcastSubscription$(T)]],
         [_removeListener]: [dart.void, [_BroadcastSubscription$(T)]],
         [_subscribe]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
@@ skipping 25 matching lines @@
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
         if (dart.notNull(this[_isEmpty]))
           return;
         if (dart.notNull(this[_hasOneListener])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_FIRING);
           let subscription = dart.as(this[_next], _BroadcastSubscription);
-          subscription[_add](data);
+          dart.dcall(subscription[_add], data);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
           if (dart.notNull(this[_isEmpty])) {
-            this[_callOnCancel]();
+            dart.dcall(this[_callOnCancel]);
           }
           return;
         }
-        this[_forEachListener](dart.fn(subscription => {
+        dart.dcall(this[_forEachListener], dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
-          subscription[_add](data);
+          dart.dcall(subscription[_add], data);
         }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
       }
       [_sendError](error, stackTrace) {
         if (dart.notNull(this[_isEmpty]))
           return;
-        this[_forEachListener](dart.fn(subscription => {
+        dart.dcall(this[_forEachListener], dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
-          subscription[_addError](error, stackTrace);
+          dart.dcall(subscription[_addError], error, stackTrace);
         }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          this[_forEachListener](dart.as(dart.fn(subscription => {
+          dart.dcall(this[_forEachListener], dart.fn(subscription => {
             dart.as(subscription, _BroadcastSubscription$(T));
-            subscription[_close]();
-          }, dart.dynamic, [_BroadcastSubscription$(T)]), __CastType2));
+            dart.dcall(subscription[_close]);
+          }, dart.dynamic, [_BroadcastSubscription$(T)]));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
-          this[_doneFuture][_asyncComplete](null);
+          dart.dcall(this[_doneFuture][_asyncComplete], null);
         }
       }
     }
     dart.setSignature(_SyncBroadcastStreamController, {
       constructors: () => ({_SyncBroadcastStreamController: [_SyncBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
   let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
     class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _AsyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
-        for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
+        for (let link = this[_next]; !dart.notNull(dart.dcall(core.identical, link, this)); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
-          subscription[_addPending](new _DelayedData(data));
+          dart.dcall(subscription[_addPending], new _DelayedData(data));
         }
       }
       [_sendError](error, stackTrace) {
-        for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
+        for (let link = this[_next]; !dart.notNull(dart.dcall(core.identical, link, this)); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
-          subscription[_addPending](new _DelayedError(error, stackTrace));
+          dart.dcall(subscription[_addPending], new _DelayedError(error, stackTrace));
         }
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
+          for (let link = this[_next]; !dart.notNull(dart.dcall(core.identical, link, this)); link = link[_next]) {
             let subscription = dart.as(link, _BroadcastSubscription$(T));
-            subscription[_addPending](dart.const(new _DelayedDone()));
+            dart.dcall(subscription[_addPending], dart.const(new _DelayedDone()));
           }
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
-          this[_doneFuture][_asyncComplete](null);
+          dart.dcall(this[_doneFuture][_asyncComplete], null);
         }
       }
     }
     dart.setSignature(_AsyncBroadcastStreamController, {
       constructors: () => ({_AsyncBroadcastStreamController: [_AsyncBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _AsyncBroadcastStreamController;
   });
   let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$();
   let _addPendingEvent = Symbol('_addPendingEvent');
   let _AsBroadcastStreamController$ = dart.generic(function(T) {
     class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
       _AsBroadcastStreamController(onListen, onCancel) {
         this[_pending] = null;
         super._SyncBroadcastStreamController(onListen, onCancel);
       }
       get [_hasPending]() {
         return this[_pending] != null && !dart.notNull(this[_pending].isEmpty);
       }
       [_addPendingEvent](event) {
         if (this[_pending] == null) {
           this[_pending] = new _StreamImplEvents();
         }
-        this[_pending].add(event);
+        dart.dcall(this[_pending].add, event);
       }
       add(data) {
         dart.as(data, T);
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
-          this[_addPendingEvent](new (_DelayedData$(T))(data));
+          dart.dcall(this[_addPendingEvent], new (_DelayedData$(T))(data));
           return;
         }
-        super.add(data);
+        dart.dcall(super.add, data);
         while (dart.notNull(this[_hasPending])) {
-          this[_pending].handleNext(this);
+          dart.dcall(this[_pending].handleNext, this);
         }
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
-          this[_addPendingEvent](new _DelayedError(error, stackTrace));
+          dart.dcall(this[_addPendingEvent], new _DelayedError(error, stackTrace));
           return;
         }
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_addEventError]());
-        this[_sendError](error, stackTrace);
+          dart.throw(dart.dcall(this[_addEventError]));
+        dart.dcall(this[_sendError], error, stackTrace);
         while (dart.notNull(this[_hasPending])) {
-          this[_pending].handleNext(this);
+          dart.dcall(this[_pending].handleNext, this);
         }
       }
       close() {
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
-          this[_addPendingEvent](dart.const(new _DelayedDone()));
+          dart.dcall(this[_addPendingEvent], dart.const(new _DelayedDone()));
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_CLOSED);
           return super.done;
         }
-        let result = super.close();
+        let result = dart.dcall(super.close);
         dart.assert(!dart.notNull(this[_hasPending]));
         return result;
       }
       [_callOnCancel]() {
         if (dart.notNull(this[_hasPending])) {
-          this[_pending].clear();
+          dart.dcall(this[_pending].clear);
           this[_pending] = null;
         }
-        super[_callOnCancel]();
+        dart.dcall(super[_callOnCancel]);
       }
     }
     _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
     dart.setSignature(_AsBroadcastStreamController, {
       constructors: () => ({_AsBroadcastStreamController: [_AsBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_addPendingEvent]: [dart.void, [_DelayedEvent]],
         add: [dart.void, [T]]
       })
     });
@@ skipping 11 matching lines @@
         dart.as(handleData, dart.functionType(dart.void, [T]));
       }
       onError(handleError) {}
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         if (resumeSignal != null)
-          resumeSignal.then(dart.bind(this, _resume));
+          dart.dcall(resumeSignal.then, dart.bind(this, _resume));
         this[_pauseCount] = dart.notNull(this[_pauseCount]) + 1;
       }
       resume() {
-        this[_resume](null);
+        dart.dcall(this[_resume], null);
       }
       [_resume](_) {
         if (dart.notNull(this[_pauseCount]) > 0) {
           this[_pauseCount] = dart.notNull(this[_pauseCount]) - 1;
         }
       }
       cancel() {
         return new _Future.immediate(null);
       }
       get isPaused() {
@@ skipping 14 matching lines @@
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         [_resume]: [dart.void, [dart.dynamic]],
         cancel: [Future, []],
         asFuture: [Future, [], [core.Object]]
       })
     });
     return _DoneSubscription;
   });
   let _DoneSubscription = _DoneSubscription$();
-  let __CastType2$ = dart.generic(function(T) {
-    let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
-    return __CastType2;
-  });
-  let __CastType2 = __CastType2$();
   class DeferredLibrary extends core.Object {
     DeferredLibrary(libraryName, opts) {
       let uri = opts && 'uri' in opts ? opts.uri : null;
       this.libraryName = libraryName;
       this.uri = uri;
     }
     load() {
       dart.throw('DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.');
     }
   }
@@ skipping 13 matching lines @@
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
   dart.setSignature(DeferredLoadException, {
     constructors: () => ({DeferredLoadException: [DeferredLoadException, [core.String]]})
   });
   let _completeWithValue = Symbol('_completeWithValue');
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       static new(computation) {
         let result = new (_Future$(T))();
-        Timer.run(dart.fn(() => {
+        dart.dcall(Timer.run, dart.fn(() => {
           try {
-            result[_complete](computation());
+            dart.dcall(result[_complete], computation());
           } catch (e) {
             let s = dart.stackTrace(e);
-            _completeWithErrorCallback(result, e, s);
+            dart.dcall(_completeWithErrorCallback, result, e, s);
           }
 
         }));
         return dart.as(result, Future$(T));
       }
       static microtask(computation) {
         let result = new (_Future$(T))();
-        scheduleMicrotask(dart.fn(() => {
+        dart.dcall(scheduleMicrotask, dart.fn(() => {
           try {
-            result[_complete](computation());
+            dart.dcall(result[_complete], computation());
           } catch (e) {
             let s = dart.stackTrace(e);
-            _completeWithErrorCallback(result, e, s);
+            dart.dcall(_completeWithErrorCallback, result, e, s);
           }
 
         }));
         return dart.as(result, Future$(T));
       }
       static sync(computation) {
         try {
           let result = computation();
           return Future$(T).value(result);
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
           return Future$(T).error(error, stackTrace);
         }
 
       }
       static value(value) {
         if (value === void 0)
           value = null;
         return new (_Future$(T)).immediate(value);
       }
       static 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);
+        error = dart.dcall(_nonNullError, error);
+        if (!dart.notNull(dart.dcall(core.identical, Zone.current, _ROOT_ZONE))) {
+          let replacement = dart.dcall(Zone.current.errorCallback, error, stackTrace);
           if (replacement != null) {
-            error = _nonNullError(replacement.error);
+            error = dart.dcall(_nonNullError, replacement.error);
             stackTrace = replacement.stackTrace;
           }
         }
         return new (_Future$(T)).immediateError(error, stackTrace);
       }
       static delayed(duration, computation) {
         if (computation === void 0)
           computation = null;
         let result = new (_Future$(T))();
         Timer.new(duration, dart.fn(() => {
           try {
-            result[_complete](computation == null ? null : computation());
+            dart.dcall(result[_complete], computation == null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
-            _completeWithErrorCallback(result, e, s);
+            dart.dcall(_completeWithErrorCallback, result, e, s);
           }
 
         }));
         return dart.as(result, Future$(T));
       }
       static wait(futures, opts) {
         let eagerError = opts && 'eagerError' in opts ? opts.eagerError : false;
         let cleanUp = opts && 'cleanUp' in opts ? opts.cleanUp : null;
         dart.as(cleanUp, dart.functionType(dart.void, [dart.dynamic]));
         let result = new (_Future$(core.List))();
         let values = null;
         let remaining = 0;
         let error = null;
         let stackTrace = null;
         function handleError(theError, theStackTrace) {
           remaining = dart.notNull(remaining) - 1;
           if (values != null) {
             if (cleanUp != null) {
               for (let value of values) {
                 if (value != null) {
                   Future$().sync(dart.fn(() => {
                     dart.dcall(cleanUp, value);
                   }));
                 }
               }
             }
             values = null;
             if (remaining == 0 || dart.notNull(eagerError)) {
-              result[_completeError](theError, dart.as(theStackTrace, core.StackTrace));
+              dart.dcall(result[_completeError], theError, theStackTrace);
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
           } else if (remaining == 0 && !dart.notNull(eagerError)) {
-            result[_completeError](error, stackTrace);
+            dart.dcall(result[_completeError], error, stackTrace);
           }
         }
         dart.fn(handleError, dart.void, [dart.dynamic, dart.dynamic]);
         for (let future of futures) {
           let pos = remaining;
           remaining = dart.notNull(pos) + 1;
-          future.then(dart.fn(value => {
+          dart.dcall(future.then, dart.fn(value => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
               values[dartx.set](pos, value);
               if (remaining == 0) {
-                result[_completeWithValue](values);
+                dart.dcall(result[_completeWithValue], values);
               }
             } else {
               if (cleanUp != null && value != null) {
                 Future$().sync(dart.fn(() => {
                   dart.dcall(cleanUp, value);
                 }));
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
-                result[_completeError](error, stackTrace);
+                dart.dcall(result[_completeError], error, stackTrace);
               }
             }
           }, dart.dynamic, [core.Object]), {onError: handleError});
         }
         if (remaining == 0) {
           return Future$(core.List).value(dart.const([]));
         }
         values = core.List.new(remaining);
         return result;
       }
       static forEach(input, f) {
         dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
         let iterator = input[dartx.iterator];
-        return Future$().doWhile(dart.fn(() => {
-          if (!dart.notNull(iterator.moveNext()))
+        return dart.dcall(Future$().doWhile, dart.fn(() => {
+          if (!dart.notNull(dart.dcall(iterator.moveNext)))
             return false;
-          return Future$().sync(dart.fn(() => dart.dcall(f, iterator.current))).then(dart.fn(_ => true, core.bool, [dart.dynamic]));
+          return dart.dcall(Future$().sync(dart.fn(() => dart.dcall(f, iterator.current))).then, dart.fn(_ => true, core.bool, [dart.dynamic]));
         }));
       }
       static doWhile(f) {
         dart.as(f, dart.functionType(dart.dynamic, []));
         let doneSignal = new _Future();
         let nextIteration = null;
-        nextIteration = Zone.current.bindUnaryCallback(dart.fn(keepGoing => {
+        nextIteration = dart.dcall(Zone.current.bindUnaryCallback, dart.fn(keepGoing => {
           if (dart.notNull(keepGoing)) {
-            Future$().sync(f).then(dart.as(nextIteration, __CastType4), {onError: dart.bind(doneSignal, _completeError)});
+            dart.dcall(Future$().sync(f).then, nextIteration, {onError: dart.bind(doneSignal, _completeError)});
           } else {
-            doneSignal[_complete](null);
+            dart.dcall(doneSignal[_complete], null);
           }
         }, dart.dynamic, [core.bool]), {runGuarded: true});
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.setSignature(Future, {
       constructors: () => ({
         new: [Future$(T), [dart.functionType(dart.dynamic, [])]],
         microtask: [Future$(T), [dart.functionType(dart.dynamic, [])]],
@@ skipping 49 matching lines @@
     dart.setSignature(Completer, {
       constructors: () => ({
         new: [Completer$(T), []],
         sync: [Completer$(T), []]
       })
     });
     return Completer;
   });
   let Completer = Completer$();
   function _completeWithErrorCallback(result, error, stackTrace) {
-    let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
+    let replacement = dart.dcall(Zone.current.errorCallback, error, stackTrace);
     if (replacement != null) {
-      error = _nonNullError(replacement.error);
+      error = dart.dcall(_nonNullError, replacement.error);
       stackTrace = replacement.stackTrace;
     }
-    result[_completeError](error, dart.as(stackTrace, core.StackTrace));
+    dart.dcall(result[_completeError], error, stackTrace);
   }
   dart.fn(_completeWithErrorCallback, () => dart.definiteFunctionType(dart.void, [_Future, dart.dynamic, dart.dynamic]));
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
   dart.fn(_nonNullError, core.Object, [core.Object]);
-  let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let _FutureOnValue$ = dart.generic(function(T) {
     let _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType(dart.dynamic, [T]));
     return _FutureOnValue;
   });
   let _FutureOnValue = _FutureOnValue$();
   let _FutureErrorTest = dart.typedef('_FutureErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
   let _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(dart.dynamic, []));
   let _Completer$ = dart.generic(function(T) {
     class _Completer extends core.Object {
       _Completer() {
         this.future = new (_Future$(T))();
       }
       completeError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        error = _nonNullError(error);
+        error = dart.dcall(_nonNullError, error);
         if (!dart.notNull(this.future[_mayComplete]))
           dart.throw(new core.StateError("Future already completed"));
-        let replacement = Zone.current.errorCallback(error, stackTrace);
+        let replacement = dart.dcall(Zone.current.errorCallback, error, stackTrace);
         if (replacement != null) {
-          error = _nonNullError(replacement.error);
+          error = dart.dcall(_nonNullError, replacement.error);
           stackTrace = replacement.stackTrace;
         }
-        this[_completeError](error, stackTrace);
+        dart.dcall(this[_completeError], error, stackTrace);
       }
       get isCompleted() {
         return !dart.notNull(this.future[_mayComplete]);
       }
     }
     _Completer[dart.implements] = () => [Completer$(T)];
     dart.setSignature(_Completer, {
       methods: () => ({completeError: [dart.void, [core.Object], [core.StackTrace]]})
     });
     return _Completer;
   });
   let _Completer = _Completer$();
   let _asyncCompleteError = Symbol('_asyncCompleteError');
   let _AsyncCompleter$ = dart.generic(function(T) {
     class _AsyncCompleter extends _Completer$(T) {
       _AsyncCompleter() {
         super._Completer();
       }
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           dart.throw(new core.StateError("Future already completed"));
-        this.future[_asyncComplete](value);
+        dart.dcall(this.future[_asyncComplete], value);
       }
       [_completeError](error, stackTrace) {
-        this.future[_asyncCompleteError](error, stackTrace);
+        dart.dcall(this.future[_asyncCompleteError], error, stackTrace);
       }
     }
     dart.setSignature(_AsyncCompleter, {
       methods: () => ({
         complete: [dart.void, [], [dart.dynamic]],
         [_completeError]: [dart.void, [core.Object, core.StackTrace]]
       })
     });
     return _AsyncCompleter;
   });
   let _AsyncCompleter = _AsyncCompleter$();
   let _SyncCompleter$ = dart.generic(function(T) {
     class _SyncCompleter extends _Completer$(T) {
       _SyncCompleter() {
         super._Completer();
       }
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           dart.throw(new core.StateError("Future already completed"));
-        this.future[_complete](value);
+        dart.dcall(this.future[_complete], value);
       }
       [_completeError](error, stackTrace) {
-        this.future[_completeError](error, stackTrace);
+        dart.dcall(this.future[_completeError], error, stackTrace);
       }
     }
     dart.setSignature(_SyncCompleter, {
       methods: () => ({
         complete: [dart.void, [], [dart.dynamic]],
         [_completeError]: [dart.void, [core.Object, core.StackTrace]]
       })
     });
     return _SyncCompleter;
   });
@@ skipping 100 matching lines @@
     class _Future extends core.Object {
       _Future() {
         this[_zone] = Zone.current;
         this[_state] = _Future$()._INCOMPLETE;
         this[_resultOrListeners] = null;
       }
       immediate(value) {
         this[_zone] = Zone.current;
         this[_state] = _Future$()._INCOMPLETE;
         this[_resultOrListeners] = null;
-        this[_asyncComplete](value);
+        dart.dcall(this[_asyncComplete], value);
       }
       immediateError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_zone] = Zone.current;
         this[_state] = _Future$()._INCOMPLETE;
         this[_resultOrListeners] = null;
-        this[_asyncCompleteError](error, stackTrace);
+        dart.dcall(this[_asyncCompleteError], error, stackTrace);
       }
       get [_mayComplete]() {
         return this[_state] == _Future$()._INCOMPLETE;
       }
       get [_isChained]() {
         return this[_state] == _Future$()._CHAINED;
       }
       get [_isComplete]() {
         return dart.notNull(this[_state]) >= dart.notNull(_Future$()._VALUE);
       }
       get [_hasValue]() {
         return this[_state] == _Future$()._VALUE;
       }
       get [_hasError]() {
         return this[_state] == _Future$()._ERROR;
       }
       set [_isChained](value) {
         if (dart.notNull(value)) {
           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$())();
-        if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
-          f = dart.as(result[_zone].registerUnaryCallback(f), __CastType6);
+        if (!dart.notNull(dart.dcall(core.identical, result[_zone], _ROOT_ZONE))) {
+          f = dart.as(dart.dcall(result[_zone].registerUnaryCallback, f), __CastType0);
           if (onError != null) {
-            onError = _registerErrorHandler(onError, result[_zone]);
+            onError = dart.dcall(_registerErrorHandler, onError, result[_zone]);
           }
         }
-        this[_addListener](new _FutureListener.then(result, f, onError));
+        dart.dcall(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$())();
-        if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
-          onError = _registerErrorHandler(onError, result[_zone]);
+        if (!dart.notNull(dart.dcall(core.identical, result[_zone], _ROOT_ZONE))) {
+          onError = dart.dcall(_registerErrorHandler, onError, result[_zone]);
           if (test != null)
-            test = dart.as(result[_zone].registerUnaryCallback(test), __CastType8);
+            test = dart.as(dart.dcall(result[_zone].registerUnaryCallback, test), __CastType2);
         }
-        this[_addListener](new _FutureListener.catchError(result, onError, test));
+        dart.dcall(this[_addListener], new _FutureListener.catchError(result, onError, test));
         return result;
       }
       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);
+        if (!dart.notNull(dart.dcall(core.identical, result[_zone], _ROOT_ZONE))) {
+          action = dart.dcall(result[_zone].registerCallback, action);
         }
-        this[_addListener](new _FutureListener.whenComplete(result, action));
+        dart.dcall(this[_addListener], new _FutureListener.whenComplete(result, action));
         return dart.as(result, Future$(T));
       }
       asStream() {
         return Stream$(T).fromFuture(this);
       }
       [_markPendingCompletion]() {
         if (!dart.notNull(this[_mayComplete]))
           dart.throw(new core.StateError("Future already completed"));
         this[_state] = _Future$()._PENDING_COMPLETE;
       }
@@ skipping 10 matching lines @@
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_state] = _Future$()._VALUE;
         this[_resultOrListeners] = value;
       }
       [_setErrorObject](error) {
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_state] = _Future$()._ERROR;
         this[_resultOrListeners] = error;
       }
       [_setError](error, stackTrace) {
-        this[_setErrorObject](new AsyncError(error, stackTrace));
+        dart.dcall(this[_setErrorObject], new AsyncError(error, stackTrace));
       }
       [_addListener](listener) {
         dart.assert(listener[_nextListener] == null);
         if (dart.notNull(this[_isComplete])) {
-          this[_zone].scheduleMicrotask(dart.fn((() => {
-            _Future$()._propagateToListeners(this, listener);
+          dart.dcall(this[_zone].scheduleMicrotask, dart.fn((() => {
+            dart.dcall(_Future$()._propagateToListeners, this, listener);
           }).bind(this)));
         } else {
           listener[_nextListener] = dart.as(this[_resultOrListeners], _FutureListener);
           this[_resultOrListeners] = listener;
         }
       }
       [_removeListeners]() {
         dart.assert(!dart.notNull(this[_isComplete]));
         let current = dart.as(this[_resultOrListeners], _FutureListener);
         this[_resultOrListeners] = null;
         let prev = null;
         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$()));
         target[_isChained] = true;
-        source.then(dart.fn(value => {
+        dart.dcall(source.then, dart.fn(value => {
           dart.assert(target[_isChained]);
-          target[_completeWithValue](value);
+          dart.dcall(target[_completeWithValue], value);
         }), {onError: dart.fn((error, stackTrace) => {
             if (stackTrace === void 0)
               stackTrace = null;
             dart.assert(target[_isChained]);
-            target[_completeError](error, dart.as(stackTrace, core.StackTrace));
+            dart.dcall(target[_completeError], error, stackTrace);
           }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
       }
       static _chainCoreFuture(source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(dart.is(source, _Future$()));
         target[_isChained] = true;
         let listener = new _FutureListener.chain(target);
         if (dart.notNull(source[_isComplete])) {
-          _Future$()._propagateToListeners(source, listener);
+          dart.dcall(_Future$()._propagateToListeners, source, listener);
         } else {
-          source[_addListener](listener);
+          dart.dcall(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);
+            dart.dcall(_Future$()._chainCoreFuture, value, this);
           } else {
-            _Future$()._chainForeignFuture(dart.as(value, Future), this);
+            dart.dcall(_Future$()._chainForeignFuture, value, this);
           }
         } else {
-          let listeners = this[_removeListeners]();
-          this[_setValue](dart.as(value, T));
-          _Future$()._propagateToListeners(this, listeners);
+          let listeners = dart.dcall(this[_removeListeners]);
+          dart.dcall(this[_setValue], value);
+          dart.dcall(_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);
+        let listeners = dart.dcall(this[_removeListeners]);
+        dart.dcall(this[_setValue], value);
+        dart.dcall(_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);
+        let listeners = dart.dcall(this[_removeListeners]);
+        dart.dcall(this[_setError], error, stackTrace);
+        dart.dcall(_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$())) {
             let coreFuture = dart.as(typedFuture, _Future$(T));
             if (dart.notNull(coreFuture[_isComplete]) && dart.notNull(coreFuture[_hasError])) {
-              this[_markPendingCompletion]();
-              this[_zone].scheduleMicrotask(dart.fn((() => {
-                _Future$()._chainCoreFuture(coreFuture, this);
+              dart.dcall(this[_markPendingCompletion]);
+              dart.dcall(this[_zone].scheduleMicrotask, dart.fn((() => {
+                dart.dcall(_Future$()._chainCoreFuture, coreFuture, this);
               }).bind(this)));
             } else {
-              _Future$()._chainCoreFuture(coreFuture, this);
+              dart.dcall(_Future$()._chainCoreFuture, coreFuture, this);
             }
           } else {
-            _Future$()._chainForeignFuture(typedFuture, this);
+            dart.dcall(_Future$()._chainForeignFuture, typedFuture, this);
           }
           return;
         } else {
           let typedValue = dart.as(value, T);
         }
-        this[_markPendingCompletion]();
-        this[_zone].scheduleMicrotask(dart.fn((() => {
-          this[_completeWithValue](value);
+        dart.dcall(this[_markPendingCompletion]);
+        dart.dcall(this[_zone].scheduleMicrotask, dart.fn((() => {
+          dart.dcall(this[_completeWithValue], value);
         }).bind(this)));
       }
       [_asyncCompleteError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isComplete]));
-        this[_markPendingCompletion]();
-        this[_zone].scheduleMicrotask(dart.fn((() => {
-          this[_completeError](error, stackTrace);
+        dart.dcall(this[_markPendingCompletion]);
+        dart.dcall(this[_zone].scheduleMicrotask, dart.fn((() => {
+          dart.dcall(this[_completeError], error, stackTrace);
         }).bind(this)));
       }
       static _propagateToListeners(source, listeners) {
         while (true) {
           dart.assert(source[_isComplete]);
           let hasError = source[_hasError];
           if (listeners == null) {
             if (dart.notNull(hasError)) {
               let asyncError = source[_error];
-              source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
+              dart.dcall(source[_zone].handleUncaughtError, asyncError.error, asyncError.stackTrace);
             }
             return;
           }
           while (listeners[_nextListener] != null) {
             let listener = listeners;
             listeners = listener[_nextListener];
             listener[_nextListener] = null;
-            _Future$()._propagateToListeners(source, listener);
+            dart.dcall(_Future$()._propagateToListeners, source, listener);
           }
           let listener = listeners;
           let listenerHasValue = true;
           let sourceValue = dart.notNull(hasError) ? null : source[_value];
           let listenerValueOrError = sourceValue;
           let isPropagationAborted = false;
           if (dart.notNull(hasError) || dart.notNull(listener.handlesValue) || dart.notNull(listener.handlesComplete)) {
             let zone = listener[_zone];
-            if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErrorZone(zone))) {
+            if (dart.notNull(hasError) && !dart.notNull(dart.dcall(source[_zone].inSameErrorZone, zone))) {
               let asyncError = source[_error];
-              source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
+              dart.dcall(source[_zone].handleUncaughtError, asyncError.error, asyncError.stackTrace);
               return;
             }
             let oldZone = null;
-            if (!dart.notNull(core.identical(Zone.current, zone))) {
-              oldZone = Zone._enter(zone);
+            if (!dart.notNull(dart.dcall(core.identical, Zone.current, zone))) {
+              oldZone = dart.dcall(Zone._enter, zone);
             }
             function handleValueCallback() {
               try {
-                listenerValueOrError = zone.runUnary(listener[_onValue], sourceValue);
+                listenerValueOrError = dart.dcall(zone.runUnary, listener[_onValue], sourceValue);
                 return true;
               } catch (e) {
                 let s = dart.stackTrace(e);
                 listenerValueOrError = new AsyncError(e, s);
                 return false;
               }
 
             }
             dart.fn(handleValueCallback, core.bool, []);
             function handleError() {
               let asyncError = source[_error];
               let matchesTest = true;
               if (dart.notNull(listener.hasErrorTest)) {
                 let test = listener[_errorTest];
                 try {
-                  matchesTest = dart.as(zone.runUnary(test, asyncError.error), core.bool);
+                  matchesTest = dart.as(dart.dcall(zone.runUnary, test, asyncError.error), core.bool);
                 } catch (e) {
                   let s = dart.stackTrace(e);
-                  listenerValueOrError = dart.notNull(core.identical(asyncError.error, e)) ? asyncError : new AsyncError(e, s);
+                  listenerValueOrError = dart.notNull(dart.dcall(core.identical, asyncError.error, e)) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
                   return;
                 }
 
               }
               let errorCallback = listener[_onError];
               if (dart.notNull(matchesTest) && errorCallback != null) {
                 try {
                   if (dart.is(errorCallback, ZoneBinaryCallback)) {
-                    listenerValueOrError = zone.runBinary(errorCallback, asyncError.error, asyncError.stackTrace);
+                    listenerValueOrError = dart.dcall(zone.runBinary, errorCallback, asyncError.error, asyncError.stackTrace);
                   } else {
-                    listenerValueOrError = zone.runUnary(dart.as(errorCallback, __CastType10), asyncError.error);
+                    listenerValueOrError = dart.dcall(zone.runUnary, errorCallback, asyncError.error);
                   }
                 } catch (e) {
                   let s = dart.stackTrace(e);
-                  listenerValueOrError = dart.notNull(core.identical(asyncError.error, e)) ? asyncError : new AsyncError(e, s);
+                  listenerValueOrError = dart.notNull(dart.dcall(core.identical, asyncError.error, e)) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
                   return;
                 }
 
                 listenerHasValue = true;
               } else {
                 listenerValueOrError = asyncError;
                 listenerHasValue = false;
               }
             }
             dart.fn(handleError, dart.void, []);
             function handleWhenCompleteCallback() {
               let completeResult = null;
               try {
-                completeResult = zone.run(listener[_whenCompleteAction]);
+                completeResult = dart.dcall(zone.run, listener[_whenCompleteAction]);
               } catch (e) {
                 let s = dart.stackTrace(e);
-                if (dart.notNull(hasError) && dart.notNull(core.identical(source[_error].error, e))) {
+                if (dart.notNull(hasError) && dart.notNull(dart.dcall(core.identical, source[_error].error, e))) {
                   listenerValueOrError = source[_error];
                 } else {
                   listenerValueOrError = new AsyncError(e, s);
                 }
                 listenerHasValue = false;
                 return;
               }
 
               if (dart.is(completeResult, Future)) {
                 let result = listener.result;
                 result[_isChained] = true;
                 isPropagationAborted = true;
                 dart.dsend(completeResult, 'then', dart.fn(ignored => {
-                  _Future$()._propagateToListeners(source, new _FutureListener.chain(result));
+                  dart.dcall(_Future$()._propagateToListeners, source, new _FutureListener.chain(result));
                 }), {onError: dart.fn((error, stackTrace) => {
                     if (stackTrace === void 0)
                       stackTrace = null;
                     if (!dart.is(completeResult, _Future$())) {
                       completeResult = new (_Future$())();
                       dart.dsend(completeResult, _setError, error, stackTrace);
                     }
-                    _Future$()._propagateToListeners(dart.as(completeResult, _Future$()), new _FutureListener.chain(result));
+                    dart.dcall(_Future$()._propagateToListeners, completeResult, new _FutureListener.chain(result));
                   }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
               }
             }
             dart.fn(handleWhenCompleteCallback, dart.void, []);
             if (!dart.notNull(hasError)) {
               if (dart.notNull(listener.handlesValue)) {
-                listenerHasValue = handleValueCallback();
+                listenerHasValue = dart.dcall(handleValueCallback);
               }
             } else {
-              handleError();
+              dart.dcall(handleError);
             }
             if (dart.notNull(listener.handlesComplete)) {
-              handleWhenCompleteCallback();
+              dart.dcall(handleWhenCompleteCallback);
             }
             if (oldZone != null)
-              Zone._leave(oldZone);
+              dart.dcall(Zone._leave, oldZone);
             if (dart.notNull(isPropagationAborted))
               return;
-            if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(sourceValue, listenerValueOrError)) && dart.is(listenerValueOrError, Future)) {
+            if (dart.notNull(listenerHasValue) && !dart.notNull(dart.dcall(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.notNull(chainSource[_isComplete])) {
                   result[_isChained] = true;
                   source = chainSource;
                   listeners = new _FutureListener.chain(result);
                   continue;
                 } else {
-                  _Future$()._chainCoreFuture(chainSource, result);
+                  dart.dcall(_Future$()._chainCoreFuture, chainSource, result);
                 }
               } else {
-                _Future$()._chainForeignFuture(chainSource, result);
+                dart.dcall(_Future$()._chainForeignFuture, chainSource, result);
               }
               return;
             }
           }
           let result = listener.result;
-          listeners = result[_removeListeners]();
+          listeners = dart.dcall(result[_removeListeners]);
           if (dart.notNull(listenerHasValue)) {
-            result[_setValue](listenerValueOrError);
+            dart.dcall(result[_setValue], listenerValueOrError);
           } else {
             let asyncError = dart.as(listenerValueOrError, AsyncError);
-            result[_setErrorObject](asyncError);
+            dart.dcall(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 (dart.notNull(this[_isComplete]))
           return new (_Future$()).immediate(this);
         let result = new (_Future$())();
         let timer = null;
         if (onTimeout == null) {
           timer = Timer.new(timeLimit, dart.fn(() => {
-            result[_completeError](new TimeoutException("Future not completed", timeLimit));
+            dart.dcall(result[_completeError], new TimeoutException("Future not completed", timeLimit));
           }));
         } else {
           let zone = Zone.current;
-          onTimeout = zone.registerCallback(onTimeout);
+          onTimeout = dart.dcall(zone.registerCallback, onTimeout);
           timer = Timer.new(timeLimit, dart.fn(() => {
             try {
-              result[_complete](zone.run(onTimeout));
+              dart.dcall(result[_complete], dart.dcall(zone.run, onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
-              result[_completeError](e, s);
+              dart.dcall(result[_completeError], e, s);
             }
 
           }));
         }
-        this.then(dart.fn(v => {
+        dart.dcall(this.then, dart.fn(v => {
           dart.as(v, T);
           if (dart.notNull(timer.isActive)) {
-            timer.cancel();
-            result[_completeWithValue](v);
+            dart.dcall(timer.cancel);
+            dart.dcall(result[_completeWithValue], v);
           }
         }, dart.dynamic, [T]), {onError: dart.fn((e, s) => {
             if (dart.notNull(timer.isActive)) {
-              timer.cancel();
-              result[_completeError](e, dart.as(s, core.StackTrace));
+              dart.dcall(timer.cancel);
+              dart.dcall(result[_completeError], e, s);
             }
           })});
         return result;
       }
     }
     _Future[dart.implements] = () => [Future$(T)];
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
     dart.setSignature(_Future, {
       constructors: () => ({
@@ skipping 27 matching lines @@
       names: ['_chainForeignFuture', '_chainCoreFuture', '_propagateToListeners']
     });
     return _Future;
   });
   let _Future = _Future$();
   _Future._INCOMPLETE = 0;
   _Future._PENDING_COMPLETE = 1;
   _Future._CHAINED = 2;
   _Future._VALUE = 4;
   _Future._ERROR = 8;
-  let __CastType6$ = dart.generic(function(T) {
-    let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(dart.dynamic, [T]));
-    return __CastType6;
+  let __CastType0$ = dart.generic(function(T) {
+    let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [T]));
+    return __CastType0;
   });
-  let __CastType6 = __CastType6$();
-  let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.dynamic]));
-  let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType0 = __CastType0$();
+  let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(core.bool, [dart.dynamic]));
   let _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(dart.void, []));
   class _AsyncCallbackEntry extends core.Object {
     _AsyncCallbackEntry(callback) {
       this.callback = callback;
       this.next = null;
     }
   }
   dart.setSignature(_AsyncCallbackEntry, {
     constructors: () => ({_AsyncCallbackEntry: [_AsyncCallbackEntry, [_AsyncCallback]]})
   });
   exports._nextCallback = null;
   exports._lastCallback = null;
   exports._lastPriorityCallback = null;
   exports._isInCallbackLoop = false;
   function _asyncRunCallbackLoop() {
     while (exports._nextCallback != null) {
       exports._lastPriorityCallback = null;
       let entry = exports._nextCallback;
       exports._nextCallback = entry.next;
       if (exports._nextCallback == null)
         exports._lastCallback = null;
-      entry.callback();
+      dart.dcall(entry.callback);
     }
   }
   dart.fn(_asyncRunCallbackLoop, dart.void, []);
   function _asyncRunCallback() {
     exports._isInCallbackLoop = true;
     try {
-      _asyncRunCallbackLoop();
+      dart.dcall(_asyncRunCallbackLoop);
     } finally {
       exports._lastPriorityCallback = null;
       exports._isInCallbackLoop = false;
       if (exports._nextCallback != null)
-        _AsyncRun._scheduleImmediate(_asyncRunCallback);
+        dart.dcall(_AsyncRun._scheduleImmediate, _asyncRunCallback);
     }
   }
   dart.fn(_asyncRunCallback, dart.void, []);
   function _scheduleAsyncCallback(callback) {
     if (exports._nextCallback == null) {
       exports._nextCallback = exports._lastCallback = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
       if (!dart.notNull(exports._isInCallbackLoop)) {
-        _AsyncRun._scheduleImmediate(_asyncRunCallback);
+        dart.dcall(_AsyncRun._scheduleImmediate, _asyncRunCallback);
       }
     } else {
       let newEntry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
       exports._lastCallback.next = newEntry;
       exports._lastCallback = newEntry;
     }
   }
   dart.fn(_scheduleAsyncCallback, dart.void, [dart.dynamic]);
   function _schedulePriorityAsyncCallback(callback) {
     let entry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
     if (exports._nextCallback == null) {
-      _scheduleAsyncCallback(callback);
+      dart.dcall(_scheduleAsyncCallback, callback);
       exports._lastPriorityCallback = exports._lastCallback;
     } else if (exports._lastPriorityCallback == null) {
       entry.next = exports._nextCallback;
       exports._nextCallback = exports._lastPriorityCallback = entry;
     } else {
       entry.next = exports._lastPriorityCallback.next;
       exports._lastPriorityCallback.next = entry;
       exports._lastPriorityCallback = entry;
       if (entry.next == null) {
         exports._lastCallback = entry;
       }
     }
   }
   dart.fn(_schedulePriorityAsyncCallback, dart.void, [dart.dynamic]);
   function scheduleMicrotask(callback) {
-    if (dart.notNull(core.identical(_ROOT_ZONE, Zone.current))) {
-      _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
+    if (dart.notNull(dart.dcall(core.identical, _ROOT_ZONE, Zone.current))) {
+      dart.dcall(_rootScheduleMicrotask, null, null, _ROOT_ZONE, callback);
       return;
     }
-    Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
+    dart.dcall(Zone.current.scheduleMicrotask, dart.dcall(Zone.current.bindCallback, callback, {runGuarded: true}));
   }
   dart.fn(scheduleMicrotask, dart.void, [dart.functionType(dart.void, [])]);
   class _AsyncRun extends core.Object {
     static _scheduleImmediate(callback) {
       dart.dcall(_AsyncRun.scheduleImmediateClosure, callback);
     }
     static _initializeScheduleImmediate() {
       if (self.scheduleImmediate != null) {
         return _AsyncRun._scheduleImmediateJsOverride;
       }
       if (self.MutationObserver != null && self.document != null) {
         let div = self.document.createElement("div");
         let span = self.document.createElement("span");
         let storedCallback = null;
         function internalCallback(_) {
-          _isolate_helper.leaveJsAsync();
+          dart.dcall(_isolate_helper.leaveJsAsync);
           let f = storedCallback;
           storedCallback = null;
           dart.dcall(f);
         }
         dart.fn(internalCallback);
         ;
         let observer = new self.MutationObserver(internalCallback);
         observer.observe(div, {childList: true});
         return dart.fn(callback => {
           dart.assert(storedCallback == null);
-          _isolate_helper.enterJsAsync();
+          dart.dcall(_isolate_helper.enterJsAsync);
           storedCallback = callback;
           div.firstChild ? div.removeChild(span) : div.appendChild(span);
         }, dart.dynamic, [dart.functionType(dart.void, [])]);
       } else if (self.setImmediate != null) {
         return _AsyncRun._scheduleImmediateWithSetImmediate;
       }
       return _AsyncRun._scheduleImmediateWithTimer;
     }
     static _scheduleImmediateJsOverride(callback) {
       function internalCallback() {
-        _isolate_helper.leaveJsAsync();
+        dart.dcall(_isolate_helper.leaveJsAsync);
         callback();
       }
       dart.fn(internalCallback);
       ;
-      _isolate_helper.enterJsAsync();
+      dart.dcall(_isolate_helper.enterJsAsync);
       self.scheduleImmediate(internalCallback);
     }
     static _scheduleImmediateWithSetImmediate(callback) {
       function internalCallback() {
-        _isolate_helper.leaveJsAsync();
+        dart.dcall(_isolate_helper.leaveJsAsync);
         callback();
       }
       dart.fn(internalCallback);
       ;
-      _isolate_helper.enterJsAsync();
+      dart.dcall(_isolate_helper.enterJsAsync);
       self.setImmediate(internalCallback);
     }
     static _scheduleImmediateWithTimer(callback) {
-      Timer._createTimer(core.Duration.ZERO, callback);
+      dart.dcall(Timer._createTimer, core.Duration.ZERO, callback);
     }
   }
   dart.setSignature(_AsyncRun, {
     statics: () => ({
       _scheduleImmediate: [dart.void, [dart.functionType(dart.void, [])]],
       _initializeScheduleImmediate: [core.Function, []],
       _scheduleImmediateJsOverride: [dart.void, [dart.functionType(dart.void, [])]],
       _scheduleImmediateWithSetImmediate: [dart.void, [dart.functionType(dart.void, [])]],
       _scheduleImmediateWithTimer: [dart.void, [dart.functionType(dart.void, [])]]
     }),
     names: ['_scheduleImmediate', '_initializeScheduleImmediate', '_scheduleImmediateJsOverride', '_scheduleImmediateWithSetImmediate', '_scheduleImmediateWithTimer']
   });
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
-      return _AsyncRun._initializeScheduleImmediate();
+      return dart.dcall(_AsyncRun._initializeScheduleImmediate);
     }
   });
   let StreamSubscription$ = dart.generic(function(T) {
     class StreamSubscription extends core.Object {}
     return StreamSubscription;
   });
   let StreamSubscription = StreamSubscription$();
   let EventSink$ = dart.generic(function(T) {
     class EventSink extends core.Object {}
     EventSink[dart.implements] = () => [core.Sink$(T)];
     return EventSink;
   });
   let EventSink = EventSink$();
   let _stream = Symbol('_stream');
   let StreamView$ = dart.generic(function(T) {
     class StreamView extends Stream$(T) {
       StreamView(stream) {
         this[_stream] = stream;
         super.Stream();
       }
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         dart.as(onListen, dart.functionType(dart.void, [StreamSubscription$(T)]));
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription$(T)]));
-        return this[_stream].asBroadcastStream({onListen: onListen, onCancel: onCancel});
+        return dart.dcall(this[_stream].asBroadcastStream, {onListen: onListen, onCancel: onCancel});
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
-        return this[_stream].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
+        return dart.dcall(this[_stream].listen, onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
       }
     }
     dart.setSignature(StreamView, {
       constructors: () => ({StreamView: [StreamView$(T), [Stream$(T)]]}),
       methods: () => ({
         asBroadcastStream: [Stream$(T), [], {onListen: dart.functionType(dart.void, [StreamSubscription$(T)]), onCancel: dart.functionType(dart.void, [StreamSubscription$(T)])}],
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]
       })
     });
     return StreamView;
@@ skipping 40 matching lines @@
     return StreamIterator;
   });
   let StreamIterator = StreamIterator$();
   let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
     class _ControllerEventSinkWrapper extends core.Object {
       _ControllerEventSinkWrapper(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
-        this[_sink].add(data);
+        dart.dcall(this[_sink].add, data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        this[_sink].addError(error, stackTrace);
+        dart.dcall(this[_sink].addError, error, stackTrace);
       }
       close() {
-        this[_sink].close();
+        dart.dcall(this[_sink].close);
       }
     }
     _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_ControllerEventSinkWrapper, {
       constructors: () => ({_ControllerEventSinkWrapper: [_ControllerEventSinkWrapper$(T), [EventSink]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [dart.dynamic], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _ControllerEventSinkWrapper;
   });
   let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
-  let __CastType12 = dart.typedef('__CastType12', () => dart.functionType(dart.void, [StreamSubscription]));
-  let __CastType14 = dart.typedef('__CastType14', () => dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace]));
-  let __CastType17 = dart.typedef('__CastType17', () => dart.functionType(dart.void, []));
-  let __CastType18 = dart.typedef('__CastType18', () => dart.functionType(dart.void, [EventSink]));
+  let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.void, [StreamSubscription]));
+  let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(dart.void, [EventSink]));
   let StreamController$ = dart.generic(function(T) {
     class StreamController extends core.Object {
       static new(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onPause = opts && 'onPause' in opts ? opts.onPause : null;
         let onResume = opts && 'onResume' in opts ? opts.onResume : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         if (onListen == null && onPause == null && onResume == null && onCancel == null) {
           return dart.as(dart.notNull(sync) ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
@@ skipping 112 matching lines @@
         if (dart.notNull(this.isClosed)) {
           return new core.StateError("Cannot add event after closing");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add event while adding a stream");
       }
       addStream(source, opts) {
         dart.as(source, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_badEventState]());
+          dart.throw(dart.dcall(this[_badEventState]));
         if (dart.notNull(this[_isCanceled]))
           return new _Future.immediate(null);
         let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
         this[_varData] = addState;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_ADDSTREAM);
         return addState.addStreamFuture;
       }
       get done() {
-        return this[_ensureDoneFuture]();
+        return dart.dcall(this[_ensureDoneFuture]);
       }
       [_ensureDoneFuture]() {
         if (this[_doneFuture] == null) {
           this[_doneFuture] = dart.notNull(this[_isCanceled]) ? Future._nullFuture : new _Future();
         }
         return this[_doneFuture];
       }
       add(value) {
         dart.as(value, T);
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_badEventState]());
-        this[_add](value);
+          dart.throw(dart.dcall(this[_badEventState]));
+        dart.dcall(this[_add], value);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        error = _nonNullError(error);
+        error = dart.dcall(_nonNullError, error);
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_badEventState]());
-        let replacement = Zone.current.errorCallback(error, stackTrace);
+          dart.throw(dart.dcall(this[_badEventState]));
+        let replacement = dart.dcall(Zone.current.errorCallback, error, stackTrace);
         if (replacement != null) {
-          error = _nonNullError(replacement.error);
+          error = dart.dcall(_nonNullError, replacement.error);
           stackTrace = replacement.stackTrace;
         }
-        this[_addError](error, stackTrace);
+        dart.dcall(this[_addError], error, stackTrace);
       }
       close() {
         if (dart.notNull(this.isClosed)) {
-          return this[_ensureDoneFuture]();
+          return dart.dcall(this[_ensureDoneFuture]);
         }
         if (!dart.notNull(this[_mayAddEvent]))
-          dart.throw(this[_badEventState]());
-        this[_closeUnchecked]();
-        return this[_ensureDoneFuture]();
+          dart.throw(dart.dcall(this[_badEventState]));
+        dart.dcall(this[_closeUnchecked]);
+        return dart.dcall(this[_ensureDoneFuture]);
       }
       [_closeUnchecked]() {
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_CLOSED);
         if (dart.notNull(this.hasListener)) {
-          this[_sendDone]();
+          dart.dcall(this[_sendDone]);
         } else if (dart.notNull(this[_isInitialState])) {
-          this[_ensurePendingEvents]().add(dart.const(new _DelayedDone()));
+          dart.dcall(dart.dcall(this[_ensurePendingEvents]).add, dart.const(new _DelayedDone()));
         }
       }
       [_add](value) {
         dart.as(value, T);
         if (dart.notNull(this.hasListener)) {
-          this[_sendData](value);
+          dart.dcall(this[_sendData], value);
         } else if (dart.notNull(this[_isInitialState])) {
-          this[_ensurePendingEvents]().add(new (_DelayedData$(T))(value));
+          dart.dcall(dart.dcall(this[_ensurePendingEvents]).add, new (_DelayedData$(T))(value));
         }
       }
       [_addError](error, stackTrace) {
         if (dart.notNull(this.hasListener)) {
-          this[_sendError](error, stackTrace);
+          dart.dcall(this[_sendError], error, stackTrace);
         } else if (dart.notNull(this[_isInitialState])) {
-          this[_ensurePendingEvents]().add(new _DelayedError(error, stackTrace));
+          dart.dcall(dart.dcall(this[_ensurePendingEvents]).add, new _DelayedError(error, stackTrace));
         }
       }
       [_close]() {
         dart.assert(this[_isAddingStream]);
         let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
         this[_varData] = addState.varData;
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_StreamController$()._STATE_ADDSTREAM);
-        addState.complete();
+        dart.dcall(addState.complete);
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (!dart.notNull(this[_isInitialState])) {
           dart.throw(new core.StateError("Stream has already been listened to."));
         }
         let subscription = new _ControllerSubscription(this, onData, onError, onDone, cancelOnError);
         let pendingEvents = this[_pendingEvents];
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_SUBSCRIBED);
         if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.varData = subscription;
-          addState.resume();
+          dart.dcall(addState.resume);
         } else {
           this[_varData] = subscription;
         }
-        subscription[_setPendingEvents](pendingEvents);
-        subscription[_guardCallback](dart.fn((() => {
-          _runGuarded(this[_onListen]);
+        dart.dcall(subscription[_setPendingEvents], pendingEvents);
+        dart.dcall(subscription[_guardCallback], dart.fn((() => {
+          dart.dcall(_runGuarded, this[_onListen]);
         }).bind(this)));
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         let result = null;
         if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
-          result = addState.cancel();
+          result = dart.dcall(addState.cancel);
         }
         this[_varData] = null;
         this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamController$()._STATE_SUBSCRIBED) | dart.notNull(_StreamController$()._STATE_ADDSTREAM)) | dart.notNull(_StreamController$()._STATE_CANCELED);
         if (this[_onCancel] != null) {
           if (result == null) {
             try {
-              result = dart.as(this[_onCancel](), Future);
+              result = dart.as(dart.dcall(this[_onCancel]), Future);
             } catch (e) {
               let s = dart.stackTrace(e);
               result = new _Future();
-              result[_asyncCompleteError](e, s);
+              dart.dcall(result[_asyncCompleteError], e, s);
             }
 
           } else {
-            result = result.whenComplete(this[_onCancel]);
+            result = dart.dcall(result.whenComplete, this[_onCancel]);
           }
         }
         let complete = (function() {
           if (this[_doneFuture] != null && dart.notNull(this[_doneFuture][_mayComplete])) {
-            this[_doneFuture][_asyncComplete](null);
+            dart.dcall(this[_doneFuture][_asyncComplete], null);
           }
         }).bind(this);
         dart.fn(complete, dart.void, []);
         if (result != null) {
-          result = result.whenComplete(complete);
+          result = dart.dcall(result.whenComplete, complete);
         } else {
-          complete();
+          dart.dcall(complete);
         }
         return result;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
-          addState.pause();
+          dart.dcall(addState.pause);
         }
-        _runGuarded(this[_onPause]);
+        dart.dcall(_runGuarded, this[_onPause]);
       }
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
-          addState.resume();
+          dart.dcall(addState.resume);
         }
-        _runGuarded(this[_onResume]);
+        dart.dcall(_runGuarded, this[_onResume]);
       }
     }
     _StreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_StreamController, {
       constructors: () => ({_StreamController: [_StreamController$(T), []]}),
       methods: () => ({
         [_ensurePendingEvents]: [_StreamImplEvents, []],
         [_badEventState]: [core.Error, []],
         addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}],
         [_ensureDoneFuture]: [Future, []],
@@ skipping 16 matching lines @@
   _StreamController._STATE_INITIAL = 0;
   _StreamController._STATE_SUBSCRIBED = 1;
   _StreamController._STATE_CANCELED = 2;
   _StreamController._STATE_SUBSCRIPTION_MASK = 3;
   _StreamController._STATE_CLOSED = 4;
   _StreamController._STATE_ADDSTREAM = 8;
   let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _SyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         dart.as(data, T);
-        this[_subscription][_add](data);
+        dart.dcall(this[_subscription][_add], data);
       }
       [_sendError](error, stackTrace) {
-        this[_subscription][_addError](error, stackTrace);
+        dart.dcall(this[_subscription][_addError], error, stackTrace);
       }
       [_sendDone]() {
-        this[_subscription][_close]();
+        dart.dcall(this[_subscription][_close]);
       }
     }
     _SyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     dart.setSignature(_SyncStreamControllerDispatch, {
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _SyncStreamControllerDispatch;
   });
   let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$();
   let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _AsyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         dart.as(data, T);
-        this[_subscription][_addPending](new _DelayedData(data));
+        dart.dcall(this[_subscription][_addPending], new _DelayedData(data));
       }
       [_sendError](error, stackTrace) {
-        this[_subscription][_addPending](new _DelayedError(error, stackTrace));
+        dart.dcall(this[_subscription][_addPending], new _DelayedError(error, stackTrace));
       }
       [_sendDone]() {
-        this[_subscription][_addPending](dart.const(new _DelayedDone()));
+        dart.dcall(this[_subscription][_addPending], dart.const(new _DelayedDone()));
       }
     }
     _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     dart.setSignature(_AsyncStreamControllerDispatch, {
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
@@ skipping 60 matching lines @@
   function _runGuarded(notificationHandler) {
     if (notificationHandler == null)
       return null;
     try {
       let result = notificationHandler();
       if (dart.is(result, Future))
         return dart.as(result, Future);
       return null;
     } catch (e) {
       let s = dart.stackTrace(e);
-      Zone.current.handleUncaughtError(e, s);
+      dart.dcall(Zone.current.handleUncaughtError, e, s);
     }
 
   }
   dart.fn(_runGuarded, Future, [_NotificationHandler]);
   let _target = Symbol('_target');
   let _StreamSinkWrapper$ = dart.generic(function(T) {
     class _StreamSinkWrapper extends core.Object {
       _StreamSinkWrapper(target) {
         this[_target] = target;
       }
       add(data) {
         dart.as(data, T);
-        this[_target].add(data);
+        dart.dcall(this[_target].add, data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        this[_target].addError(error, stackTrace);
+        dart.dcall(this[_target].addError, error, stackTrace);
       }
       close() {
-        return this[_target].close();
+        return dart.dcall(this[_target].close);
       }
       addStream(source, opts) {
         dart.as(source, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
-        return this[_target].addStream(source, {cancelOnError: cancelOnError});
+        return dart.dcall(this[_target].addStream, source, {cancelOnError: cancelOnError});
       }
       get done() {
         return this[_target].done;
       }
     }
     _StreamSinkWrapper[dart.implements] = () => [StreamSink$(T)];
     dart.setSignature(_StreamSinkWrapper, {
       constructors: () => ({_StreamSinkWrapper: [_StreamSinkWrapper$(T), [StreamController]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [Future, []],
         addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}]
       })
     });
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$();
   let _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
-        this.addSubscription = source.listen(dart.bind(controller, _add), {onError: dart.notNull(cancelOnError) ? dart.as(_AddStreamState$().makeErrorHandler(controller), core.Function) : dart.bind(controller, _addError), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
+        this.addSubscription = dart.dcall(source.listen, dart.bind(controller, _add), {onError: dart.notNull(cancelOnError) ? dart.dcall(_AddStreamState$().makeErrorHandler, controller) : dart.bind(controller, _addError), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return dart.fn((e, s) => {
-          controller[_addError](e, s);
-          controller[_close]();
+          dart.dcall(controller[_addError], e, s);
+          dart.dcall(controller[_close]);
         }, dart.dynamic, [dart.dynamic, core.StackTrace]);
       }
       pause() {
-        this.addSubscription.pause();
+        dart.dcall(this.addSubscription.pause);
       }
       resume() {
-        this.addSubscription.resume();
+        dart.dcall(this.addSubscription.resume);
       }
       cancel() {
-        let cancel = this.addSubscription.cancel();
+        let cancel = dart.dcall(this.addSubscription.cancel);
         if (cancel == null) {
-          this.addStreamFuture[_asyncComplete](null);
+          dart.dcall(this.addStreamFuture[_asyncComplete], null);
           return null;
         }
-        return cancel.whenComplete(dart.fn((() => {
-          this.addStreamFuture[_asyncComplete](null);
-        }).bind(this)));
+        return dart.as(dart.dsend(cancel, 'whenComplete', dart.fn((() => {
+          dart.dcall(this.addStreamFuture[_asyncComplete], null);
+        }).bind(this))), Future);
       }
       complete() {
-        this.addStreamFuture[_asyncComplete](null);
+        dart.dcall(this.addStreamFuture[_asyncComplete], null);
       }
     }
     dart.setSignature(_AddStreamState, {
       constructors: () => ({_AddStreamState: [_AddStreamState$(T), [_EventSink$(T), Stream, core.bool]]}),
       methods: () => ({
         pause: [dart.void, []],
         resume: [dart.void, []],
         cancel: [Future, []],
         complete: [dart.void, []]
       }),
       statics: () => ({makeErrorHandler: [dart.dynamic, [_EventSink]]}),
       names: ['makeErrorHandler']
     });
     return _AddStreamState;
   });
   let _AddStreamState = _AddStreamState$();
   let _StreamControllerAddStreamState$ = dart.generic(function(T) {
     class _StreamControllerAddStreamState extends _AddStreamState$(T) {
       _StreamControllerAddStreamState(controller, varData, source, cancelOnError) {
         this.varData = varData;
         super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cancelOnError);
         if (dart.notNull(controller.isPaused)) {
-          this.addSubscription.pause();
+          dart.dcall(this.addSubscription.pause);
         }
       }
     }
     dart.setSignature(_StreamControllerAddStreamState, {
       constructors: () => ({_StreamControllerAddStreamState: [_StreamControllerAddStreamState$(T), [_StreamController, dart.dynamic, Stream, core.bool]]})
     });
     return _StreamControllerAddStreamState;
   });
   let _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
   let _EventSink$ = dart.generic(function(T) {
@@ skipping 24 matching lines @@
         this[_isUsed] = false;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (dart.notNull(this[_isUsed]))
           dart.throw(new core.StateError("Stream has already been listened to."));
         this[_isUsed] = true;
         return dart.as((() => {
           let _ = new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
-          _[_setPendingEvents](this[_pending]());
+          dart.dcall(_[_setPendingEvents], dart.dcall(this[_pending]));
           return _;
         }).bind(this)(), StreamSubscription$(T));
       }
     }
     dart.setSignature(_GeneratedStreamImpl, {
       constructors: () => ({_GeneratedStreamImpl: [_GeneratedStreamImpl$(T), [_EventGenerator]]}),
       methods: () => ({[_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
     });
     return _GeneratedStreamImpl;
   });
@@ skipping 11 matching lines @@
     }
     schedule(dispatch) {
       if (dart.notNull(this.isScheduled))
         return;
       dart.assert(!dart.notNull(this.isEmpty));
       if (dart.notNull(this[_eventScheduled])) {
         dart.assert(this[_state] == _PendingEvents._STATE_CANCELED);
         this[_state] = _PendingEvents._STATE_SCHEDULED;
         return;
       }
-      scheduleMicrotask(dart.fn((() => {
+      dart.dcall(scheduleMicrotask, dart.fn((() => {
         let oldState = this[_state];
         this[_state] = _PendingEvents._STATE_UNSCHEDULED;
         if (oldState == _PendingEvents._STATE_CANCELED)
           return;
-        this.handleNext(dispatch);
+        dart.dcall(this.handleNext, dispatch);
       }).bind(this)));
       this[_state] = _PendingEvents._STATE_SCHEDULED;
     }
     cancelSchedule() {
       if (dart.notNull(this.isScheduled))
         this[_state] = _PendingEvents._STATE_CANCELED;
     }
   }
   dart.setSignature(_PendingEvents, {
     methods: () => ({
@@ skipping 10 matching lines @@
       }
       get isEmpty() {
         return this[_iterator] == null;
       }
       handleNext(dispatch) {
         if (this[_iterator] == null) {
           dart.throw(new core.StateError("No events pending."));
         }
         let isDone = null;
         try {
-          isDone = !dart.notNull(this[_iterator].moveNext());
+          isDone = !dart.notNull(dart.dcall(this[_iterator].moveNext));
         } catch (e) {
           let s = dart.stackTrace(e);
           this[_iterator] = null;
-          dispatch[_sendError](e, s);
+          dart.dcall(dispatch[_sendError], e, s);
           return;
         }
 
         if (!dart.notNull(isDone)) {
-          dispatch[_sendData](this[_iterator].current);
+          dart.dcall(dispatch[_sendData], this[_iterator].current);
         } else {
           this[_iterator] = null;
-          dispatch[_sendDone]();
+          dart.dcall(dispatch[_sendDone]);
         }
       }
       clear() {
         if (dart.notNull(this.isScheduled))
-          this.cancelSchedule();
+          dart.dcall(this.cancelSchedule);
         this[_iterator] = null;
       }
     }
     dart.setSignature(_IterablePendingEvents, {
       constructors: () => ({_IterablePendingEvents: [_IterablePendingEvents$(T), [core.Iterable$(T)]]}),
       methods: () => ({
         handleNext: [dart.void, [_EventDispatch]],
         clear: [dart.void, []]
       })
     });
     return _IterablePendingEvents;
   });
   let _IterablePendingEvents = _IterablePendingEvents$();
   let _DataHandler$ = dart.generic(function(T) {
     let _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart.void, [T]));
     return _DataHandler;
   });
   let _DataHandler = _DataHandler$();
   let _DoneHandler = dart.typedef('_DoneHandler', () => dart.functionType(dart.void, []));
   function _nullDataHandler(value) {
   }
   dart.fn(_nullDataHandler, dart.void, [dart.dynamic]);
   function _nullErrorHandler(error, stackTrace) {
     if (stackTrace === void 0)
       stackTrace = null;
-    Zone.current.handleUncaughtError(error, stackTrace);
+    dart.dcall(Zone.current.handleUncaughtError, error, stackTrace);
   }
   dart.fn(_nullErrorHandler, dart.void, [dart.dynamic], [core.StackTrace]);
   function _nullDoneHandler() {
   }
   dart.fn(_nullDoneHandler, dart.void, []);
   let _DelayedEvent$ = dart.generic(function(T) {
     class _DelayedEvent extends core.Object {
       _DelayedEvent() {
         this.next = null;
       }
     }
     return _DelayedEvent;
   });
   let _DelayedEvent = _DelayedEvent$();
   let _DelayedData$ = dart.generic(function(T) {
     class _DelayedData extends _DelayedEvent$(T) {
       _DelayedData(value) {
         this.value = value;
         super._DelayedEvent();
       }
       perform(dispatch) {
         dart.as(dispatch, _EventDispatch$(T));
-        dispatch[_sendData](this.value);
+        dart.dcall(dispatch[_sendData], this.value);
       }
     }
     dart.setSignature(_DelayedData, {
       constructors: () => ({_DelayedData: [_DelayedData$(T), [T]]}),
       methods: () => ({perform: [dart.void, [_EventDispatch$(T)]]})
     });
     return _DelayedData;
   });
   let _DelayedData = _DelayedData$();
   class _DelayedError extends _DelayedEvent {
     _DelayedError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
       super._DelayedEvent();
     }
     perform(dispatch) {
-      dispatch[_sendError](this.error, this.stackTrace);
+      dart.dcall(dispatch[_sendError], this.error, this.stackTrace);
     }
   }
   dart.setSignature(_DelayedError, {
     constructors: () => ({_DelayedError: [_DelayedError, [dart.dynamic, core.StackTrace]]}),
     methods: () => ({perform: [dart.void, [_EventDispatch]]})
   });
   class _DelayedDone extends core.Object {
     _DelayedDone() {
     }
     perform(dispatch) {
-      dispatch[_sendDone]();
+      dart.dcall(dispatch[_sendDone]);
     }
     get next() {
       return null;
     }
     set next(_) {
       dart.throw(new core.StateError("No events after a done."));
     }
   }
   _DelayedDone[dart.implements] = () => [_DelayedEvent];
   dart.setSignature(_DelayedDone, {
@@ skipping 19 matching lines @@
         this.lastPendingEvent = this.lastPendingEvent.next = event;
       }
     }
     handleNext(dispatch) {
       dart.assert(!dart.notNull(this.isScheduled));
       let event = this.firstPendingEvent;
       this.firstPendingEvent = event.next;
       if (this.firstPendingEvent == null) {
         this.lastPendingEvent = null;
       }
-      event.perform(dispatch);
+      dart.dcall(event.perform, dispatch);
     }
     clear() {
       if (dart.notNull(this.isScheduled))
-        this.cancelSchedule();
+        dart.dcall(this.cancelSchedule);
       this.firstPendingEvent = this.lastPendingEvent = null;
     }
   }
   dart.setSignature(_StreamImplEvents, {
     methods: () => ({
       add: [dart.void, [_DelayedEvent]],
       handleNext: [dart.void, [_EventDispatch]],
       clear: [dart.void, []]
     })
   });
@@ skipping 26 matching lines @@
   let _broadcastCallback = dart.typedef('_broadcastCallback', () => dart.functionType(dart.void, [StreamSubscription]));
   let _schedule = Symbol('_schedule');
   let _isSent = Symbol('_isSent');
   let _isScheduled = Symbol('_isScheduled');
   let _DoneStreamSubscription$ = dart.generic(function(T) {
     class _DoneStreamSubscription extends core.Object {
       _DoneStreamSubscription(onDone) {
         this[_onDone] = onDone;
         this[_zone] = Zone.current;
         this[_state] = 0;
-        this[_schedule]();
+        dart.dcall(this[_schedule]);
       }
       get [_isSent]() {
         return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription$()._DONE_SENT)) != 0;
       }
       get [_isScheduled]() {
         return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription$()._SCHEDULED)) != 0;
       }
       get isPaused() {
         return dart.notNull(this[_state]) >= dart.notNull(_DoneStreamSubscription$()._PAUSED);
       }
       [_schedule]() {
         if (dart.notNull(this[_isScheduled]))
           return;
-        this[_zone].scheduleMicrotask(dart.bind(this, _sendDone));
+        dart.dcall(this[_zone].scheduleMicrotask, dart.bind(this, _sendDone));
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
       }
       onData(handleData) {
         dart.as(handleData, dart.functionType(dart.void, [T]));
       }
       onError(handleError) {}
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
         this[_onDone] = handleDone;
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_DoneStreamSubscription$()._PAUSED);
         if (resumeSignal != null)
-          resumeSignal.whenComplete(dart.bind(this, 'resume'));
+          dart.dcall(resumeSignal.whenComplete, dart.bind(this, 'resume'));
       }
       resume() {
         if (dart.notNull(this.isPaused)) {
           this[_state] = dart.notNull(this[_state]) - dart.notNull(_DoneStreamSubscription$()._PAUSED);
           if (!dart.notNull(this.isPaused) && !dart.notNull(this[_isSent])) {
-            this[_schedule]();
+            dart.dcall(this[_schedule]);
           }
         }
       }
       cancel() {
         return null;
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new _Future();
         this[_onDone] = dart.fn(() => {
-          result[_completeWithValue](null);
+          dart.dcall(result[_completeWithValue], null);
         });
         return result;
       }
       [_sendDone]() {
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
         if (dart.notNull(this.isPaused))
           return;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._DONE_SENT);
         if (this[_onDone] != null)
-          this[_zone].runGuarded(this[_onDone]);
+          dart.dcall(this[_zone].runGuarded, this[_onDone]);
       }
     }
     _DoneStreamSubscription[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_DoneStreamSubscription, {
       constructors: () => ({_DoneStreamSubscription: [_DoneStreamSubscription$(T), [_DoneHandler]]}),
       methods: () => ({
         [_schedule]: [dart.void, []],
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
@@ skipping 14 matching lines @@
   let _onListenHandler = Symbol('_onListenHandler');
   let _onCancelHandler = Symbol('_onCancelHandler');
   let _cancelSubscription = Symbol('_cancelSubscription');
   let _pauseSubscription = Symbol('_pauseSubscription');
   let _resumeSubscription = Symbol('_resumeSubscription');
   let _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
   let _AsBroadcastStream$ = dart.generic(function(T) {
     class _AsBroadcastStream extends Stream$(T) {
       _AsBroadcastStream(source, onListenHandler, onCancelHandler) {
         this[_source] = source;
-        this[_onListenHandler] = dart.as(Zone.current.registerUnaryCallback(onListenHandler), _broadcastCallback);
-        this[_onCancelHandler] = dart.as(Zone.current.registerUnaryCallback(onCancelHandler), _broadcastCallback);
+        this[_onListenHandler] = dart.as(dart.dcall(Zone.current.registerUnaryCallback, onListenHandler), _broadcastCallback);
+        this[_onCancelHandler] = dart.as(dart.dcall(Zone.current.registerUnaryCallback, onCancelHandler), _broadcastCallback);
         this[_zone] = Zone.current;
         this[_controller] = null;
         this[_subscription] = null;
         super.Stream();
         this[_controller] = new (_AsBroadcastStreamController$(T))(dart.bind(this, _onListen), dart.bind(this, _onCancel));
       }
       get isBroadcast() {
         return true;
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         if (this[_controller] == null || dart.notNull(this[_controller].isClosed)) {
           return new (_DoneStreamSubscription$(T))(onDone);
         }
         if (this[_subscription] == null) {
-          this[_subscription] = this[_source].listen(dart.bind(this[_controller], 'add'), {onError: dart.bind(this[_controller], 'addError'), onDone: dart.bind(this[_controller], 'close')});
+          this[_subscription] = dart.dcall(this[_source].listen, dart.bind(this[_controller], 'add'), {onError: dart.bind(this[_controller], 'addError'), onDone: dart.bind(this[_controller], 'close')});
         }
-        cancelOnError = core.identical(true, cancelOnError);
-        return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
+        cancelOnError = dart.dcall(core.identical, true, cancelOnError);
+        return dart.dcall(this[_controller][_subscribe], onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
         let shutdown = this[_controller] == null || dart.notNull(this[_controller].isClosed);
         if (this[_onCancelHandler] != null) {
-          this[_zone].runUnary(this[_onCancelHandler], new _BroadcastSubscriptionWrapper(this));
+          dart.dcall(this[_zone].runUnary, this[_onCancelHandler], new _BroadcastSubscriptionWrapper(this));
         }
         if (dart.notNull(shutdown)) {
           if (this[_subscription] != null) {
-            this[_subscription].cancel();
+            dart.dcall(this[_subscription].cancel);
             this[_subscription] = null;
           }
         }
       }
       [_onListen]() {
         if (this[_onListenHandler] != null) {
-          this[_zone].runUnary(this[_onListenHandler], new _BroadcastSubscriptionWrapper(this));
+          dart.dcall(this[_zone].runUnary, this[_onListenHandler], new _BroadcastSubscriptionWrapper(this));
         }
       }
       [_cancelSubscription]() {
         if (this[_subscription] == null)
           return;
         let subscription = this[_subscription];
         this[_subscription] = null;
         this[_controller] = null;
-        subscription.cancel();
+        dart.dcall(subscription.cancel);
       }
       [_pauseSubscription](resumeSignal) {
         if (this[_subscription] == null)
           return;
-        this[_subscription].pause(resumeSignal);
+        dart.dcall(this[_subscription].pause, resumeSignal);
       }
       [_resumeSubscription]() {
         if (this[_subscription] == null)
           return;
-        this[_subscription].resume();
+        dart.dcall(this[_subscription].resume);
       }
       get [_isSubscriptionPaused]() {
         if (this[_subscription] == null)
           return false;
         return this[_subscription].isPaused;
       }
     }
     dart.setSignature(_AsBroadcastStream, {
       constructors: () => ({_AsBroadcastStream: [_AsBroadcastStream$(T), [Stream$(T), dart.functionType(dart.void, [StreamSubscription]), dart.functionType(dart.void, [StreamSubscription])]]}),
       methods: () => ({
@@ skipping 20 matching lines @@
       onError(handleError) {
         dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
       }
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
         dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
-        this[_stream][_pauseSubscription](resumeSignal);
+        dart.dcall(this[_stream][_pauseSubscription], resumeSignal);
       }
       resume() {
-        this[_stream][_resumeSubscription]();
+        dart.dcall(this[_stream][_resumeSubscription]);
       }
       cancel() {
-        this[_stream][_cancelSubscription]();
+        dart.dcall(this[_stream][_cancelSubscription]);
         return null;
       }
       get isPaused() {
         return this[_stream][_isSubscriptionPaused];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
       }
@@ skipping 17 matching lines @@
   let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
   let _clear = Symbol('_clear');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends core.Object {
       _StreamIteratorImpl(stream) {
         this[_subscription] = null;
         this[_current] = null;
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl$()._STATE_FOUND;
-        this[_subscription] = stream.listen(dart.bind(this, _onData), {onError: dart.bind(this, _onError), onDone: dart.bind(this, _onDone), cancelOnError: true});
+        this[_subscription] = dart.dcall(stream.listen, dart.bind(this, _onData), {onError: dart.bind(this, _onError), onDone: dart.bind(this, _onDone), cancelOnError: true});
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (this[_state] == _StreamIteratorImpl$()._STATE_DONE) {
           return new (_Future$(core.bool)).immediate(false);
         }
         if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
           dart.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();
+              dart.dcall(this[_subscription].resume);
               return new (_Future$(core.bool)).immediate(true);
             }
             case _StreamIteratorImpl$()._STATE_EXTRA_ERROR:
             {
               let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
-              this[_clear]();
+              dart.dcall(this[_clear]);
               return new (_Future$(core.bool)).immediateError(prefetch.error, prefetch.stackTrace);
             }
             case _StreamIteratorImpl$()._STATE_EXTRA_DONE:
             {
-              this[_clear]();
+              dart.dcall(this[_clear]);
               return new (_Future$(core.bool)).immediate(false);
             }
           }
         }
       }
       [_clear]() {
         this[_subscription] = null;
         this[_futureOrPrefetch] = null;
         this[_current] = null;
         this[_state] = _StreamIteratorImpl$()._STATE_DONE;
       }
       cancel() {
         let subscription = this[_subscription];
         if (subscription == null)
           return null;
         if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
-          this[_clear]();
-          hasNext[_complete](false);
+          dart.dcall(this[_clear]);
+          dart.dcall(hasNext[_complete], false);
         } else {
-          this[_clear]();
+          dart.dcall(this[_clear]);
         }
-        return subscription.cancel();
+        return dart.dcall(subscription.cancel);
       }
       [_onData](data) {
         dart.as(data, T);
         if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
           this[_current] = data;
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_futureOrPrefetch] = null;
           this[_state] = _StreamIteratorImpl$()._STATE_FOUND;
-          hasNext[_complete](true);
+          dart.dcall(hasNext[_complete], true);
           return;
         }
-        this[_subscription].pause();
+        dart.dcall(this[_subscription].pause);
         dart.assert(this[_futureOrPrefetch] == null);
         this[_futureOrPrefetch] = data;
         this[_state] = _StreamIteratorImpl$()._STATE_EXTRA_DATA;
       }
       [_onError](error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
-          this[_clear]();
-          hasNext[_completeError](error, stackTrace);
+          dart.dcall(this[_clear]);
+          dart.dcall(hasNext[_completeError], error, stackTrace);
           return;
         }
-        this[_subscription].pause();
+        dart.dcall(this[_subscription].pause);
         dart.assert(this[_futureOrPrefetch] == null);
         this[_futureOrPrefetch] = new AsyncError(error, stackTrace);
         this[_state] = _StreamIteratorImpl$()._STATE_EXTRA_ERROR;
       }
       [_onDone]() {
         if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
-          this[_clear]();
-          hasNext[_complete](false);
+          dart.dcall(this[_clear]);
+          dart.dcall(hasNext[_complete], false);
           return;
         }
-        this[_subscription].pause();
+        dart.dcall(this[_subscription].pause);
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl$()._STATE_EXTRA_DONE;
       }
     }
     _StreamIteratorImpl[dart.implements] = () => [StreamIterator$(T)];
     dart.setSignature(_StreamIteratorImpl, {
       constructors: () => ({_StreamIteratorImpl: [_StreamIteratorImpl$(T), [Stream$(T)]]}),
       methods: () => ({
         moveNext: [Future$(core.bool), []],
         [_clear]: [dart.void, []],
         cancel: [Future, []],
         [_onData]: [dart.void, [T]],
         [_onError]: [dart.void, [core.Object], [core.StackTrace]],
         [_onDone]: [dart.void, []]
       })
     });
     return _StreamIteratorImpl;
   });
   let _StreamIteratorImpl = _StreamIteratorImpl$();
   _StreamIteratorImpl._STATE_FOUND = 0;
   _StreamIteratorImpl._STATE_DONE = 1;
   _StreamIteratorImpl._STATE_MOVING = 2;
   _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
   _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
   _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
-  let __CastType20$ = dart.generic(function(T) {
-    let __CastType20 = dart.typedef('__CastType20', () => dart.functionType(dart.void, [T]));
-    return __CastType20;
+  let __CastType8$ = dart.generic(function(T) {
+    let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(dart.void, [T]));
+    return __CastType8;
   });
-  let __CastType20 = __CastType20$();
-  let __CastType22 = dart.typedef('__CastType22', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
-  let __CastType25 = dart.typedef('__CastType25', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType8 = __CastType8$();
   function _runUserCode(userCode, onSuccess, onError) {
     try {
       dart.dcall(onSuccess, userCode());
     } catch (e) {
       let s = dart.stackTrace(e);
-      let replacement = Zone.current.errorCallback(e, s);
+      let replacement = dart.dcall(Zone.current.errorCallback, e, s);
       if (replacement == null) {
         dart.dcall(onError, e, s);
       } else {
-        let error = _nonNullError(replacement.error);
+        let error = dart.dcall(_nonNullError, replacement.error);
         let stackTrace = replacement.stackTrace;
         dart.dcall(onError, error, stackTrace);
       }
     }
 
   }
   dart.fn(_runUserCode, dart.dynamic, [dart.functionType(dart.dynamic, []), dart.functionType(dart.dynamic, [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])]);
   function _cancelAndError(subscription, future, error, stackTrace) {
-    let cancelFuture = subscription.cancel();
+    let cancelFuture = dart.dcall(subscription.cancel);
     if (dart.is(cancelFuture, Future)) {
-      cancelFuture.whenComplete(dart.fn(() => future[_completeError](error, stackTrace), dart.void, []));
+      dart.dsend(cancelFuture, 'whenComplete', dart.fn(() => dart.dcall(future[_completeError], error, stackTrace), dart.void, []));
     } else {
-      future[_completeError](error, stackTrace);
+      dart.dcall(future[_completeError], error, stackTrace);
     }
   }
   dart.fn(_cancelAndError, dart.void, [StreamSubscription, _Future, dart.dynamic, core.StackTrace]);
   function _cancelAndErrorWithReplacement(subscription, future, error, stackTrace) {
-    let replacement = Zone.current.errorCallback(error, stackTrace);
+    let replacement = dart.dcall(Zone.current.errorCallback, error, stackTrace);
     if (replacement != null) {
-      error = _nonNullError(replacement.error);
+      error = dart.dcall(_nonNullError, replacement.error);
       stackTrace = replacement.stackTrace;
     }
-    _cancelAndError(subscription, future, error, stackTrace);
+    dart.dcall(_cancelAndError, subscription, future, error, stackTrace);
   }
   dart.fn(_cancelAndErrorWithReplacement, dart.void, [StreamSubscription, _Future, dart.dynamic, core.StackTrace]);
   function _cancelAndErrorClosure(subscription, future) {
-    return dart.fn((error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace), dart.void, [dart.dynamic, core.StackTrace]);
+    return dart.fn((error, stackTrace) => dart.dcall(_cancelAndError, subscription, future, error, stackTrace), dart.void, [dart.dynamic, core.StackTrace]);
   }
   dart.fn(_cancelAndErrorClosure, dart.dynamic, [StreamSubscription, _Future]);
   function _cancelAndValue(subscription, future, value) {
-    let cancelFuture = subscription.cancel();
+    let cancelFuture = dart.dcall(subscription.cancel);
     if (dart.is(cancelFuture, Future)) {
-      cancelFuture.whenComplete(dart.fn(() => future[_complete](value), dart.void, []));
+      dart.dsend(cancelFuture, 'whenComplete', dart.fn(() => dart.dcall(future[_complete], value), dart.void, []));
     } else {
-      future[_complete](value);
+      dart.dcall(future[_complete], value);
     }
   }
   dart.fn(_cancelAndValue, dart.void, [StreamSubscription, _Future, dart.dynamic]);
   let _handleData = Symbol('_handleData');
   let _handleError = Symbol('_handleError');
   let _handleDone = Symbol('_handleDone');
   let _ForwardingStream$ = dart.generic(function(S, T) {
     class _ForwardingStream extends Stream$(T) {
       _ForwardingStream(source) {
         this[_source] = source;
         super.Stream();
       }
       get isBroadcast() {
         return this[_source].isBroadcast;
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
-        cancelOnError = core.identical(true, cancelOnError);
-        return this[_createSubscription](onData, onError, onDone, cancelOnError);
+        cancelOnError = dart.dcall(core.identical, true, cancelOnError);
+        return dart.dcall(this[_createSubscription], onData, onError, onDone, cancelOnError);
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         return new (_ForwardingStreamSubscription$(S, T))(this, onData, onError, onDone, cancelOnError);
       }
       [_handleData](data, sink) {
         dart.as(data, S);
         dart.as(sink, _EventSink$(T));
         let outputData = data;
-        sink[_add](dart.as(outputData, T));
+        dart.dcall(sink[_add], outputData);
       }
       [_handleError](error, stackTrace, sink) {
         dart.as(sink, _EventSink$(T));
-        sink[_addError](error, stackTrace);
+        dart.dcall(sink[_addError], error, stackTrace);
       }
       [_handleDone](sink) {
         dart.as(sink, _EventSink$(T));
-        sink[_close]();
+        dart.dcall(sink[_close]);
       }
     }
     dart.setSignature(_ForwardingStream, {
       constructors: () => ({_ForwardingStream: [_ForwardingStream$(S, T), [Stream$(S)]]}),
       methods: () => ({
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_handleData]: [dart.void, [S, _EventSink$(T)]],
         [_handleError]: [dart.void, [dart.dynamic, core.StackTrace, _EventSink$(T)]],
         [_handleDone]: [dart.void, [_EventSink$(T)]]
       })
     });
     return _ForwardingStream;
   });
   let _ForwardingStream = _ForwardingStream$();
   let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
     class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
       _ForwardingStreamSubscription(stream, onData, onError, onDone, cancelOnError) {
         this[_stream] = stream;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
-        this[_subscription] = this[_stream][_source].listen(dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
+        this[_subscription] = dart.dcall(this[_stream][_source].listen, dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
       }
       [_add](data) {
         dart.as(data, T);
         if (dart.notNull(this[_isClosed]))
           return;
-        super[_add](data);
+        dart.dcall(super[_add], data);
       }
       [_addError](error, stackTrace) {
         if (dart.notNull(this[_isClosed]))
           return;
-        super[_addError](error, stackTrace);
+        dart.dcall(super[_addError], error, stackTrace);
       }
       [_onPause]() {
         if (this[_subscription] == null)
           return;
-        this[_subscription].pause();
+        dart.dcall(this[_subscription].pause);
       }
       [_onResume]() {
         if (this[_subscription] == null)
           return;
-        this[_subscription].resume();
+        dart.dcall(this[_subscription].resume);
       }
       [_onCancel]() {
         if (this[_subscription] != null) {
           let subscription = this[_subscription];
           this[_subscription] = null;
-          subscription.cancel();
+          dart.dcall(subscription.cancel);
         }
         return null;
       }
       [_handleData](data) {
         dart.as(data, S);
-        this[_stream][_handleData](data, this);
+        dart.dcall(this[_stream][_handleData], data, this);
       }
       [_handleError](error, stackTrace) {
-        this[_stream][_handleError](error, stackTrace, this);
+        dart.dcall(this[_stream][_handleError], error, stackTrace, this);
       }
       [_handleDone]() {
-        this[_stream][_handleDone](this);
+        dart.dcall(this[_stream][_handleDone], this);
       }
     }
     dart.setSignature(_ForwardingStreamSubscription, {
       constructors: () => ({_ForwardingStreamSubscription: [_ForwardingStreamSubscription$(S, T), [_ForwardingStream$(S, T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
         [_handleError]: [dart.void, [dart.dynamic, core.StackTrace]],
         [_handleDone]: [dart.void, []]
       })
     });
     return _ForwardingStreamSubscription;
   });
   let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
   let _Predicate$ = dart.generic(function(T) {
     let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _Predicate = _Predicate$();
   function _addErrorWithReplacement(sink, error, stackTrace) {
-    let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
+    let replacement = dart.dcall(Zone.current.errorCallback, error, stackTrace);
     if (replacement != null) {
-      error = _nonNullError(replacement.error);
+      error = dart.dcall(_nonNullError, replacement.error);
       stackTrace = replacement.stackTrace;
     }
-    sink[_addError](error, dart.as(stackTrace, core.StackTrace));
+    dart.dcall(sink[_addError], error, stackTrace);
   }
   dart.fn(_addErrorWithReplacement, dart.void, [_EventSink, dart.dynamic, dart.dynamic]);
   let _test = Symbol('_test');
   let _WhereStream$ = dart.generic(function(T) {
     class _WhereStream extends _ForwardingStream$(T, T) {
       _WhereStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         let satisfies = null;
         try {
-          satisfies = this[_test](inputEvent);
+          satisfies = dart.dcall(this[_test], inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
-          _addErrorWithReplacement(sink, e, s);
+          dart.dcall(_addErrorWithReplacement, sink, e, s);
           return;
         }
 
         if (dart.notNull(satisfies)) {
-          sink[_add](inputEvent);
+          dart.dcall(sink[_add], inputEvent);
         }
       }
     }
     dart.setSignature(_WhereStream, {
       constructors: () => ({_WhereStream: [_WhereStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _WhereStream;
   });
   let _WhereStream = _WhereStream$();
@@ skipping 10 matching lines @@
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, S);
         dart.as(sink, _EventSink$(T));
         let outputEvent = null;
         try {
           outputEvent = dart.as(dart.dcall(this[_transform], inputEvent), T);
         } catch (e) {
           let s = dart.stackTrace(e);
-          _addErrorWithReplacement(sink, e, s);
+          dart.dcall(_addErrorWithReplacement, sink, e, s);
           return;
         }
 
-        sink[_add](outputEvent);
+        dart.dcall(sink[_add], outputEvent);
       }
     }
     dart.setSignature(_MapStream, {
       constructors: () => ({_MapStream: [_MapStream$(S, T), [Stream$(S), dart.functionType(T, [S])]]}),
       methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _MapStream;
   });
   let _MapStream = _MapStream$();
   let _expand = Symbol('_expand');
   let _ExpandStream$ = dart.generic(function(S, T) {
     class _ExpandStream extends _ForwardingStream$(S, T) {
       _ExpandStream(source, expand) {
         this[_expand] = expand;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, S);
         dart.as(sink, _EventSink$(T));
         try {
-          for (let value of this[_expand](inputEvent)) {
-            sink[_add](value);
+          for (let value of dart.dcall(this[_expand], inputEvent)) {
+            dart.dcall(sink[_add], value);
           }
         } catch (e) {
           let s = dart.stackTrace(e);
-          _addErrorWithReplacement(sink, e, s);
+          dart.dcall(_addErrorWithReplacement, sink, e, s);
         }
 
       }
     }
     dart.setSignature(_ExpandStream, {
       constructors: () => ({_ExpandStream: [_ExpandStream$(S, T), [Stream$(S), dart.functionType(core.Iterable$(T), [S])]]}),
       methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _ExpandStream;
   });
   let _ExpandStream = _ExpandStream$();
   let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
   let _HandleErrorStream$ = dart.generic(function(T) {
     class _HandleErrorStream extends _ForwardingStream$(T, T) {
       _HandleErrorStream(source, onError, test) {
         this[_transform] = onError;
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleError](error, stackTrace, sink) {
         dart.as(sink, _EventSink$(T));
         let matches = true;
         if (this[_test] != null) {
           try {
             matches = dart.dcall(this[_test], error);
           } catch (e) {
             let s = dart.stackTrace(e);
-            _addErrorWithReplacement(sink, e, s);
+            dart.dcall(_addErrorWithReplacement, sink, e, s);
             return;
           }
 
         }
         if (dart.notNull(matches)) {
           try {
-            _invokeErrorHandler(this[_transform], error, stackTrace);
+            dart.dcall(_invokeErrorHandler, this[_transform], error, stackTrace);
           } catch (e) {
             let s = dart.stackTrace(e);
-            if (dart.notNull(core.identical(e, error))) {
-              sink[_addError](error, stackTrace);
+            if (dart.notNull(dart.dcall(core.identical, e, error))) {
+              dart.dcall(sink[_addError], error, stackTrace);
             } else {
-              _addErrorWithReplacement(sink, e, s);
+              dart.dcall(_addErrorWithReplacement, sink, e, s);
             }
             return;
           }
 
         } else {
-          sink[_addError](error, stackTrace);
+          dart.dcall(sink[_addError], error, stackTrace);
         }
       }
     }
     dart.setSignature(_HandleErrorStream, {
       constructors: () => ({_HandleErrorStream: [_HandleErrorStream$(T), [Stream$(T), core.Function, dart.functionType(core.bool, [dart.dynamic])]]}),
       methods: () => ({[_handleError]: [dart.void, [core.Object, core.StackTrace, _EventSink$(T)]]})
     });
     return _HandleErrorStream;
   });
   let _HandleErrorStream = _HandleErrorStream$();
   let _remaining = Symbol('_remaining');
   let _TakeStream$ = dart.generic(function(T) {
     class _TakeStream extends _ForwardingStream$(T, T) {
       _TakeStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number'))
           dart.throw(new core.ArgumentError(count));
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
-          sink[_add](inputEvent);
+          dart.dcall(sink[_add], inputEvent);
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           if (this[_remaining] == 0) {
-            sink[_close]();
+            dart.dcall(sink[_close]);
           }
         }
       }
     }
     dart.setSignature(_TakeStream, {
       constructors: () => ({_TakeStream: [_TakeStream$(T), [Stream$(T), core.int]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _TakeStream;
   });
   let _TakeStream = _TakeStream$();
   let _TakeWhileStream$ = dart.generic(function(T) {
     class _TakeWhileStream extends _ForwardingStream$(T, T) {
       _TakeWhileStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         let satisfies = null;
         try {
-          satisfies = this[_test](inputEvent);
+          satisfies = dart.dcall(this[_test], inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
-          _addErrorWithReplacement(sink, e, s);
-          sink[_close]();
+          dart.dcall(_addErrorWithReplacement, sink, e, s);
+          dart.dcall(sink[_close]);
           return;
         }
 
         if (dart.notNull(satisfies)) {
-          sink[_add](inputEvent);
+          dart.dcall(sink[_add], inputEvent);
         } else {
-          sink[_close]();
+          dart.dcall(sink[_close]);
         }
       }
     }
     dart.setSignature(_TakeWhileStream, {
       constructors: () => ({_TakeWhileStream: [_TakeWhileStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _TakeWhileStream;
   });
   let _TakeWhileStream = _TakeWhileStream$();
   let _SkipStream$ = dart.generic(function(T) {
     class _SkipStream extends _ForwardingStream$(T, T) {
       _SkipStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number') || dart.notNull(count) < 0)
           dart.throw(new core.ArgumentError(count));
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           return;
         }
-        sink[_add](inputEvent);
+        dart.dcall(sink[_add], inputEvent);
       }
     }
     dart.setSignature(_SkipStream, {
       constructors: () => ({_SkipStream: [_SkipStream$(T), [Stream$(T), core.int]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _SkipStream;
   });
   let _SkipStream = _SkipStream$();
   let _hasFailed = Symbol('_hasFailed');
   let _SkipWhileStream$ = dart.generic(function(T) {
     class _SkipWhileStream extends _ForwardingStream$(T, T) {
       _SkipWhileStream(source, test) {
         this[_test] = test;
         this[_hasFailed] = false;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_hasFailed])) {
-          sink[_add](inputEvent);
+          dart.dcall(sink[_add], inputEvent);
           return;
         }
         let satisfies = null;
         try {
-          satisfies = this[_test](inputEvent);
+          satisfies = dart.dcall(this[_test], inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
-          _addErrorWithReplacement(sink, e, s);
+          dart.dcall(_addErrorWithReplacement, sink, e, s);
           this[_hasFailed] = true;
           return;
         }
 
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
-          sink[_add](inputEvent);
+          dart.dcall(sink[_add], inputEvent);
         }
       }
     }
     dart.setSignature(_SkipWhileStream, {
       constructors: () => ({_SkipWhileStream: [_SkipWhileStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _SkipWhileStream;
   });
   let _SkipWhileStream = _SkipWhileStream$();
   let _Equality$ = dart.generic(function(T) {
     let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
     return _Equality;
   });
   let _Equality = _Equality$();
   let _equals = Symbol('_equals');
   let _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
         this[_previous] = _DistinctStream$()._SENTINEL;
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
-        if (dart.notNull(core.identical(this[_previous], _DistinctStream$()._SENTINEL))) {
+        if (dart.notNull(dart.dcall(core.identical, this[_previous], _DistinctStream$()._SENTINEL))) {
           this[_previous] = inputEvent;
-          return sink[_add](inputEvent);
+          return dart.dcall(sink[_add], inputEvent);
         } else {
           let isEqual = null;
           try {
             if (this[_equals] == null) {
               isEqual = dart.equals(this[_previous], inputEvent);
             } else {
-              isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
+              isEqual = dart.dcall(this[_equals], this[_previous], inputEvent);
             }
           } catch (e) {
             let s = dart.stackTrace(e);
-            _addErrorWithReplacement(sink, e, s);
+            dart.dcall(_addErrorWithReplacement, sink, e, s);
             return null;
           }
 
           if (!dart.notNull(isEqual)) {
-            sink[_add](inputEvent);
+            dart.dcall(sink[_add], inputEvent);
             this[_previous] = inputEvent;
           }
         }
       }
     }
     dart.setSignature(_DistinctStream, {
       constructors: () => ({_DistinctStream: [_DistinctStream$(T), [Stream$(T), dart.functionType(core.bool, [T, T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
   dart.defineLazyProperties(_DistinctStream, {
     get _SENTINEL() {
       return new core.Object();
     },
     set _SENTINEL(_) {}
   });
   let _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
       _EventSinkWrapper(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
-        this[_sink][_add](data);
+        dart.dcall(this[_sink][_add], data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        this[_sink][_addError](error, stackTrace);
+        dart.dcall(this[_sink][_addError], error, stackTrace);
       }
       close() {
-        this[_sink][_close]();
+        dart.dcall(this[_sink][_close]);
       }
     }
     _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_EventSinkWrapper, {
       constructors: () => ({_EventSinkWrapper: [_EventSinkWrapper$(T), [_EventSink]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [dart.dynamic], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _EventSinkWrapper;
   });
   let _EventSinkWrapper = _EventSinkWrapper$();
   let _transformerSink = Symbol('_transformerSink');
   let _isSubscribed = Symbol('_isSubscribed');
   let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
     class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
       _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
         this[_transformerSink] = null;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
-        this[_subscription] = source.listen(dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
+        this[_subscription] = dart.dcall(source.listen, dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
       }
       get [_isSubscribed]() {
         return this[_subscription] != null;
       }
       [_add](data) {
         dart.as(data, T);
         if (dart.notNull(this[_isClosed])) {
           dart.throw(new core.StateError("Stream is already closed"));
         }
-        super[_add](data);
+        dart.dcall(super[_add], data);
       }
       [_addError](error, stackTrace) {
         if (dart.notNull(this[_isClosed])) {
           dart.throw(new core.StateError("Stream is already closed"));
         }
-        super[_addError](error, stackTrace);
+        dart.dcall(super[_addError], error, stackTrace);
       }
       [_close]() {
         if (dart.notNull(this[_isClosed])) {
           dart.throw(new core.StateError("Stream is already closed"));
         }
-        super[_close]();
+        dart.dcall(super[_close]);
       }
       [_onPause]() {
         if (dart.notNull(this[_isSubscribed]))
-          this[_subscription].pause();
+          dart.dcall(this[_subscription].pause);
       }
       [_onResume]() {
         if (dart.notNull(this[_isSubscribed]))
-          this[_subscription].resume();
+          dart.dcall(this[_subscription].resume);
       }
       [_onCancel]() {
         if (dart.notNull(this[_isSubscribed])) {
           let subscription = this[_subscription];
           this[_subscription] = null;
-          subscription.cancel();
+          dart.dcall(subscription.cancel);
         }
         return null;
       }
       [_handleData](data) {
         dart.as(data, S);
         try {
-          this[_transformerSink].add(data);
+          dart.dcall(this[_transformerSink].add, data);
         } catch (e) {
           let s = dart.stackTrace(e);
-          this[_addError](e, s);
+          dart.dcall(this[_addError], e, s);
         }
 
       }
       [_handleError](error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         try {
-          this[_transformerSink].addError(error, dart.as(stackTrace, core.StackTrace));
+          dart.dcall(this[_transformerSink].addError, error, stackTrace);
         } catch (e) {
           let s = dart.stackTrace(e);
-          if (dart.notNull(core.identical(e, error))) {
-            this[_addError](error, dart.as(stackTrace, core.StackTrace));
+          if (dart.notNull(dart.dcall(core.identical, e, error))) {
+            dart.dcall(this[_addError], error, stackTrace);
           } else {
-            this[_addError](e, s);
+            dart.dcall(this[_addError], e, s);
           }
         }
 
       }
       [_handleDone]() {
         try {
           this[_subscription] = null;
-          this[_transformerSink].close();
+          dart.dcall(this[_transformerSink].close);
         } catch (e) {
           let s = dart.stackTrace(e);
-          this[_addError](e, s);
+          dart.dcall(this[_addError], e, s);
         }
 
       }
     }
     dart.setSignature(_SinkTransformerStreamSubscription, {
       constructors: () => ({_SinkTransformerStreamSubscription: [_SinkTransformerStreamSubscription$(S, T), [Stream$(S), _SinkMapper$(S, T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
         [_handleError]: [dart.void, [dart.dynamic], [dart.dynamic]],
@@ skipping 36 matching lines @@
         this[_stream] = stream;
         this[_sinkMapper] = sinkMapper;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
-        cancelOnError = core.identical(true, cancelOnError);
+        cancelOnError = dart.dcall(core.identical, true, cancelOnError);
         let subscription = new (_SinkTransformerStreamSubscription$(dart.dynamic, T))(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     dart.setSignature(_BoundSinkStream, {
       constructors: () => ({_BoundSinkStream: [_BoundSinkStream$(S, T), [Stream$(S), _SinkMapper$(S, T)]]}),
       methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]})
     });
     return _BoundSinkStream;
   });
@@ skipping 16 matching lines @@
   let _HandlerEventSink$ = dart.generic(function(S, T) {
     class _HandlerEventSink extends core.Object {
       _HandlerEventSink(handleData, handleError, handleDone, sink) {
         this[_handleData] = handleData;
         this[_handleError] = handleError;
         this[_handleDone] = handleDone;
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, S);
-        return this[_handleData](data, this[_sink]);
+        return dart.dcall(this[_handleData], data, this[_sink]);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        return this[_handleError](error, stackTrace, this[_sink]);
+        return dart.dcall(this[_handleError], error, stackTrace, this[_sink]);
       }
       close() {
-        return this[_handleDone](this[_sink]);
+        return dart.dcall(this[_handleDone], this[_sink]);
       }
     }
     _HandlerEventSink[dart.implements] = () => [EventSink$(S)];
     dart.setSignature(_HandlerEventSink, {
       constructors: () => ({_HandlerEventSink: [_HandlerEventSink$(S, T), [_TransformDataHandler$(S, T), _TransformErrorHandler$(T), _TransformDoneHandler$(T), EventSink$(T)]]}),
       methods: () => ({
         add: [dart.void, [S]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _HandlerEventSink;
   });
   let _HandlerEventSink = _HandlerEventSink$();
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opts) {
         let handleData = opts && 'handleData' in opts ? opts.handleData : null;
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
         super._StreamSinkTransformer(dart.as(dart.fn(outputSink => {
           dart.as(outputSink, EventSink$(T));
           if (handleData == null)
-            handleData = dart.as(_StreamHandlerTransformer$()._defaultHandleData, __CastType27);
+            handleData = dart.as(_StreamHandlerTransformer$()._defaultHandleData, __CastType10);
           if (handleError == null)
-            handleError = dart.as(_StreamHandlerTransformer$()._defaultHandleError, __CastType30);
+            handleError = dart.as(_StreamHandlerTransformer$()._defaultHandleError, __CastType13);
           if (handleDone == null)
             handleDone = _StreamHandlerTransformer$()._defaultHandleDone;
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
         }, dart.dynamic, [EventSink$(T)]), _SinkMapper$(S, T)));
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
-        return super.bind(stream);
+        return dart.dcall(super.bind, stream);
       }
       static _defaultHandleData(data, sink) {
-        sink.add(data);
+        dart.dcall(sink.add, data);
       }
       static _defaultHandleError(error, stackTrace, sink) {
-        sink.addError(error);
+        dart.dcall(sink.addError, error);
       }
       static _defaultHandleDone(sink) {
-        sink.close();
+        dart.dcall(sink.close);
       }
     }
     dart.setSignature(_StreamHandlerTransformer, {
       constructors: () => ({_StreamHandlerTransformer: [_StreamHandlerTransformer$(S, T), [], {handleData: dart.functionType(dart.void, [S, EventSink$(T)]), handleError: dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]), handleDone: dart.functionType(dart.void, [EventSink$(T)])}]}),
       methods: () => ({bind: [Stream$(T), [Stream$(S)]]}),
       statics: () => ({
         _defaultHandleData: [dart.void, [dart.dynamic, EventSink]],
         _defaultHandleError: [dart.void, [dart.dynamic, core.StackTrace, EventSink]],
         _defaultHandleDone: [dart.void, [EventSink]]
       }),
@@ skipping 32 matching lines @@
         this[_stream] = stream;
         this[_transformer] = transformer;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
-        cancelOnError = core.identical(true, cancelOnError);
-        let result = this[_transformer](this[_stream], cancelOnError);
-        result.onData(onData);
-        result.onError(onError);
-        result.onDone(onDone);
+        cancelOnError = dart.dcall(core.identical, true, cancelOnError);
+        let result = dart.dcall(this[_transformer], this[_stream], cancelOnError);
+        dart.dcall(result.onData, onData);
+        dart.dcall(result.onError, onError);
+        dart.dcall(result.onDone, onDone);
         return result;
       }
     }
     dart.setSignature(_BoundSubscriptionStream, {
       constructors: () => ({_BoundSubscriptionStream: [_BoundSubscriptionStream$(S, T), [Stream$(S), _SubscriptionTransformer$(S, T)]]}),
       methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]})
     });
     return _BoundSubscriptionStream;
   });
   let _BoundSubscriptionStream = _BoundSubscriptionStream$();
-  let __CastType27$ = dart.generic(function(S, T) {
-    let __CastType27 = dart.typedef('__CastType27', () => dart.functionType(dart.void, [S, EventSink$(T)]));
-    return __CastType27;
+  let __CastType10$ = dart.generic(function(S, T) {
+    let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.void, [S, EventSink$(T)]));
+    return __CastType10;
   });
-  let __CastType27 = __CastType27$();
-  let __CastType30$ = dart.generic(function(T) {
-    let __CastType30 = dart.typedef('__CastType30', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
-    return __CastType30;
+  let __CastType10 = __CastType10$();
+  let __CastType13$ = dart.generic(function(T) {
+    let __CastType13 = dart.typedef('__CastType13', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
+    return __CastType13;
   });
-  let __CastType30 = __CastType30$();
+  let __CastType13 = __CastType13$();
   class Timer extends core.Object {
     static new(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
-        return Zone.current.createTimer(duration, callback);
+        return dart.dcall(Zone.current.createTimer, duration, callback);
       }
-      return Zone.current.createTimer(duration, Zone.current.bindCallback(callback, {runGuarded: true}));
+      return dart.dcall(Zone.current.createTimer, duration, dart.dcall(Zone.current.bindCallback, callback, {runGuarded: true}));
     }
     static periodic(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
-        return Zone.current.createPeriodicTimer(duration, callback);
+        return dart.dcall(Zone.current.createPeriodicTimer, duration, callback);
       }
-      return Zone.current.createPeriodicTimer(duration, dart.as(Zone.current.bindUnaryCallback(callback, {runGuarded: true}), __CastType34));
+      return dart.dcall(Zone.current.createPeriodicTimer, duration, dart.dcall(Zone.current.bindUnaryCallback, callback, {runGuarded: true}));
     }
     static run(callback) {
       Timer.new(core.Duration.ZERO, callback);
     }
     static _createTimer(duration, callback) {
       let milliseconds = duration.inMilliseconds;
       if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl(milliseconds, callback);
     }
     static _createPeriodicTimer(duration, callback) {
       let milliseconds = duration.inMilliseconds;
       if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl.periodic(milliseconds, callback);
     }
   }
   dart.setSignature(Timer, {
     constructors: () => ({
       new: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       periodic: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
     }),
     statics: () => ({
       run: [dart.void, [dart.functionType(dart.void, [])]],
       _createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       _createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
     }),
     names: ['run', '_createTimer', '_createPeriodicTimer']
   });
-  let __CastType34 = dart.typedef('__CastType34', () => dart.functionType(dart.void, [Timer]));
   let ZoneCallback = dart.typedef('ZoneCallback', () => dart.functionType(dart.dynamic, []));
   let ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let ZoneBinaryCallback = dart.typedef('ZoneBinaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   let HandleUncaughtErrorHandler = dart.typedef('HandleUncaughtErrorHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]));
   let RunHandler = dart.typedef('RunHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
   let RunUnaryHandler = dart.typedef('RunUnaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]));
   let RunBinaryHandler = dart.typedef('RunBinaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]));
   let RegisterCallbackHandler = dart.typedef('RegisterCallbackHandler', () => dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
   let RegisterUnaryCallbackHandler = dart.typedef('RegisterUnaryCallbackHandler', () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]));
   let RegisterBinaryCallbackHandler = dart.typedef('RegisterBinaryCallbackHandler', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]));
@@ skipping 64 matching lines @@
       this.errorCallback = errorCallback;
       this.scheduleMicrotask = scheduleMicrotask;
       this.createTimer = createTimer;
       this.createPeriodicTimer = createPeriodicTimer;
       this.print = print;
       this.fork = fork;
     }
   }
   _ZoneSpecification[dart.implements] = () => [ZoneSpecification];
   dart.setSignature(_ZoneSpecification, {
-    constructors: () => ({_ZoneSpecification: [_ZoneSpecification, [], {handleUncaughtError: HandleUncaughtErrorHandler, run: RunHandler, runUnary: RunUnaryHandler, runBinary: RunBinaryHandler, registerCallback: RegisterCallbackHandler, registerUnaryCallback: RegisterUnaryCallbackHandler, registerBinaryCallback: RegisterBinaryCallbackHandler, errorCallback: ErrorCallbackHandler, scheduleMicrotask: ScheduleMicrotaskHandler, createTimer: CreateTimerHandler, createPeriodicTimer: CreatePeriodicTimerHandler, print: PrintHandler, fork: ForkHandler}]})
+    constructors: () => ({_ZoneSpecification: [_ZoneSpecification, [], {handleUncaughtError: dart.dynamic, run: dart.dynamic, runUnary: dart.dynamic, runBinary: dart.dynamic, registerCallback: dart.dynamic, registerUnaryCallback: dart.dynamic, registerBinaryCallback: dart.dynamic, errorCallback: dart.dynamic, scheduleMicrotask: dart.dynamic, createTimer: dart.dynamic, createPeriodicTimer: dart.dynamic, print: dart.dynamic, fork: dart.dynamic}]})
   });
   class ZoneDelegate extends core.Object {}
   class Zone extends core.Object {
     _() {
     }
     static get current() {
       return Zone._current;
     }
     static _enter(zone) {
       dart.assert(zone != null);
-      dart.assert(!dart.notNull(core.identical(zone, Zone._current)));
+      dart.assert(!dart.notNull(dart.dcall(core.identical, zone, Zone._current)));
       let previous = Zone._current;
       Zone._current = zone;
       return previous;
     }
     static _leave(previous) {
       dart.assert(previous != null);
       Zone._current = previous;
     }
   }
   dart.defineNamedConstructor(Zone, '_');
   dart.setSignature(Zone, {
     constructors: () => ({_: [Zone, []]}),
     statics: () => ({
       _enter: [Zone, [Zone]],
       _leave: [dart.void, [Zone]]
     }),
     names: ['_enter', '_leave']
   });
   class _Zone extends core.Object {
     _Zone() {
     }
     inSameErrorZone(otherZone) {
-      return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
+      return dart.notNull(dart.dcall(core.identical, this, otherZone)) || dart.notNull(dart.dcall(core.identical, this.errorZone, otherZone.errorZone));
     }
   }
   _Zone[dart.implements] = () => [Zone];
   dart.setSignature(_Zone, {
     constructors: () => ({_Zone: [_Zone, []]}),
     methods: () => ({inSameErrorZone: [core.bool, [Zone]]})
   });
   let _run = Symbol('_run');
   let _runUnary = Symbol('_runUnary');
   let _runBinary = Symbol('_runBinary');
   let _registerCallback = Symbol('_registerCallback');
   let _registerUnaryCallback = Symbol('_registerUnaryCallback');
   let _registerBinaryCallback = Symbol('_registerBinaryCallback');
   let _errorCallback = Symbol('_errorCallback');
   let _scheduleMicrotask = Symbol('_scheduleMicrotask');
   let _createTimer = Symbol('_createTimer');
   let _createPeriodicTimer = Symbol('_createPeriodicTimer');
   let _print = Symbol('_print');
   let _fork = Symbol('_fork');
   let _handleUncaughtError = Symbol('_handleUncaughtError');
   let _map = Symbol('_map');
   let _delegate = Symbol('_delegate');
   class _RootZone extends _Zone {
     _RootZone() {
       super._Zone();
     }
     get [_run]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRun));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootRun));
     }
     get [_runUnary]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunUnary));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootRunUnary));
     }
     get [_runBinary]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunBinary));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootRunBinary));
     }
     get [_registerCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootRegisterCallback));
     }
     get [_registerUnaryCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootRegisterUnaryCallback));
     }
     get [_registerBinaryCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootRegisterBinaryCallback));
     }
     get [_errorCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootErrorCallback));
     }
     get [_scheduleMicrotask]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootScheduleMicrotask));
     }
     get [_createTimer]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootCreateTimer));
     }
     get [_createPeriodicTimer]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootCreatePeriodicTimer));
     }
     get [_print]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootPrint));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootPrint));
     }
     get [_fork]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootFork));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootFork));
     }
     get [_handleUncaughtError]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError));
+      return dart.const(new _ZoneFunction(dart.as(_ROOT_ZONE, _Zone), _rootHandleUncaughtError));
     }
     get parent() {
       return null;
     }
     get [_map]() {
       return _RootZone._rootMap;
     }
     get [_delegate]() {
       if (_RootZone._rootDelegate != null)
         return _RootZone._rootDelegate;
       return _RootZone._rootDelegate = new _ZoneDelegate(this);
     }
     get errorZone() {
       return this;
     }
     runGuarded(f) {
       try {
-        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
+        if (dart.notNull(dart.dcall(core.identical, _ROOT_ZONE, Zone._current))) {
           return f();
         }
-        return _rootRun(null, null, this, f);
+        return dart.dcall(_rootRun, null, null, this, f);
       } catch (e) {
         let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
+        return dart.dcall(this.handleUncaughtError, e, s);
       }
 
     }
     runUnaryGuarded(f, arg) {
       try {
-        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
+        if (dart.notNull(dart.dcall(core.identical, _ROOT_ZONE, Zone._current))) {
           return dart.dcall(f, arg);
         }
-        return _rootRunUnary(null, null, this, f, arg);
+        return dart.dcall(_rootRunUnary, null, null, this, f, arg);
       } catch (e) {
         let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
+        return dart.dcall(this.handleUncaughtError, e, s);
       }
 
     }
     runBinaryGuarded(f, arg1, arg2) {
       try {
-        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
+        if (dart.notNull(dart.dcall(core.identical, _ROOT_ZONE, Zone._current))) {
           return dart.dcall(f, arg1, arg2);
         }
-        return _rootRunBinary(null, null, this, f, arg1, arg2);
+        return dart.dcall(_rootRunBinary, null, null, this, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
+        return dart.dcall(this.handleUncaughtError, e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (dart.notNull(runGuarded)) {
-        return dart.fn((() => this.runGuarded(f)).bind(this));
+        return dart.fn((() => dart.dcall(this.runGuarded, f)).bind(this));
       } else {
-        return dart.fn((() => this.run(f)).bind(this));
+        return dart.fn((() => dart.dcall(this.run, f)).bind(this));
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (dart.notNull(runGuarded)) {
-        return dart.fn((arg => this.runUnaryGuarded(f, arg)).bind(this));
+        return dart.fn((arg => dart.dcall(this.runUnaryGuarded, f, arg)).bind(this));
       } else {
-        return dart.fn((arg => this.runUnary(f, arg)).bind(this));
+        return dart.fn((arg => dart.dcall(this.runUnary, f, arg)).bind(this));
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (dart.notNull(runGuarded)) {
-        return dart.fn(((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this));
+        return dart.fn(((arg1, arg2) => dart.dcall(this.runBinaryGuarded, f, arg1, arg2)).bind(this));
       } else {
-        return dart.fn(((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this));
+        return dart.fn(((arg1, arg2) => dart.dcall(this.runBinary, f, arg1, arg2)).bind(this));
       }
     }
     get(key) {
       return null;
     }
     handleUncaughtError(error, stackTrace) {
-      return _rootHandleUncaughtError(null, null, this, error, stackTrace);
+      return dart.dcall(_rootHandleUncaughtError, null, null, this, error, stackTrace);
     }
     fork(opts) {
       let specification = opts && 'specification' in opts ? opts.specification : null;
       let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
-      return _rootFork(null, null, this, specification, zoneValues);
+      return dart.dcall(_rootFork, null, null, this, specification, zoneValues);
     }
     run(f) {
-      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
+      if (dart.notNull(dart.dcall(core.identical, Zone._current, _ROOT_ZONE)))
         return f();
-      return _rootRun(null, null, this, f);
+      return dart.dcall(_rootRun, null, null, this, f);
     }
     runUnary(f, arg) {
-      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
+      if (dart.notNull(dart.dcall(core.identical, Zone._current, _ROOT_ZONE)))
         return dart.dcall(f, arg);
-      return _rootRunUnary(null, null, this, f, arg);
+      return dart.dcall(_rootRunUnary, null, null, this, f, arg);
     }
     runBinary(f, arg1, arg2) {
-      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
+      if (dart.notNull(dart.dcall(core.identical, Zone._current, _ROOT_ZONE)))
         return dart.dcall(f, arg1, arg2);
-      return _rootRunBinary(null, null, this, f, arg1, arg2);
+      return dart.dcall(_rootRunBinary, null, null, this, f, arg1, arg2);
     }
     registerCallback(f) {
       return f;
     }
     registerUnaryCallback(f) {
       return f;
     }
     registerBinaryCallback(f) {
       return f;
     }
     errorCallback(error, stackTrace) {
       return null;
     }
     scheduleMicrotask(f) {
-      _rootScheduleMicrotask(null, null, this, f);
+      dart.dcall(_rootScheduleMicrotask, null, null, this, f);
     }
     createTimer(duration, f) {
-      return Timer._createTimer(duration, f);
+      return dart.dcall(Timer._createTimer, duration, f);
     }
     createPeriodicTimer(duration, f) {
-      return Timer._createPeriodicTimer(duration, f);
+      return dart.dcall(Timer._createPeriodicTimer, duration, f);
     }
     print(line) {
-      _internal.printToConsole(line);
+      dart.dcall(_internal.printToConsole, line);
     }
   }
   dart.setSignature(_RootZone, {
     constructors: () => ({_RootZone: [_RootZone, []]}),
     methods: () => ({
       runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
       runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
       runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
       bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {runGuarded: core.bool}],
       bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {runGuarded: core.bool}],
       bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {runGuarded: core.bool}],
       get: [dart.dynamic, [core.Object]],
       handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
       fork: [Zone, [], {specification: ZoneSpecification, zoneValues: core.Map}],
       run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
       runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
       runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
       registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
       registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
       registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
       errorCallback: [AsyncError, [core.Object, core.StackTrace]],
       scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
       createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
       print: [dart.void, [core.String]]
     })
   });
   let _ROOT_ZONE = dart.const(new _RootZone());
-  Zone.ROOT = _ROOT_ZONE;
-  Zone._current = _ROOT_ZONE;
+  Zone.ROOT = dart.as(_ROOT_ZONE, Zone);
+  dart.defineLazyProperties(Zone, {
+    get _current() {
+      return dart.as(_ROOT_ZONE, Zone);
+    },
+    set _current(_) {}
+  });
   function _parentDelegate(zone) {
     if (zone.parent == null)
       return null;
     return zone.parent[_delegate];
   }
   dart.fn(_parentDelegate, ZoneDelegate, [_Zone]);
   let _delegationTarget = Symbol('_delegationTarget');
   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.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace);
+      return dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, error, stackTrace);
     }
     run(zone, f) {
       let implementation = this[_delegationTarget][_run];
       let implZone = implementation.zone;
-      return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f);
+      return dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, f);
     }
     runUnary(zone, f, arg) {
       let implementation = this[_delegationTarget][_runUnary];
       let implZone = implementation.zone;
-      return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f, arg);
+      return dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, f, arg);
     }
     runBinary(zone, f, arg1, arg2) {
       let implementation = this[_delegationTarget][_runBinary];
       let implZone = implementation.zone;
-      return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f, arg1, arg2);
+      return dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, f, arg1, arg2);
     }
     registerCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneCallback);
+      return dart.as(dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, f), ZoneCallback);
     }
     registerUnaryCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerUnaryCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneUnaryCallback);
+      return dart.as(dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, f), ZoneUnaryCallback);
     }
     registerBinaryCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerBinaryCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneBinaryCallback);
+      return dart.as(dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, f), ZoneBinaryCallback);
     }
     errorCallback(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_errorCallback];
       let implZone = implementation.zone;
-      if (dart.notNull(core.identical(implZone, _ROOT_ZONE)))
+      if (dart.notNull(dart.dcall(core.identical, implZone, _ROOT_ZONE)))
         return null;
-      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace), AsyncError);
+      return dart.as(dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(zone, f) {
       let implementation = this[_delegationTarget][_scheduleMicrotask];
       let implZone = implementation.zone;
-      dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f);
+      dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, f);
     }
     createTimer(zone, duration, f) {
       let implementation = this[_delegationTarget][_createTimer];
       let implZone = implementation.zone;
-      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, duration, f), Timer);
+      return dart.as(dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, duration, f), Timer);
     }
     createPeriodicTimer(zone, period, f) {
       let implementation = this[_delegationTarget][_createPeriodicTimer];
       let implZone = implementation.zone;
-      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, period, f), Timer);
+      return dart.as(dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, period, f), Timer);
     }
     print(zone, line) {
       let implementation = this[_delegationTarget][_print];
       let implZone = implementation.zone;
-      dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, line);
+      dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, line);
     }
     fork(zone, specification, zoneValues) {
       let implementation = this[_delegationTarget][_fork];
       let implZone = implementation.zone;
-      return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
+      return dart.as(dart.dcall(implementation.function, implZone, dart.dcall(_parentDelegate, implZone), zone, specification, zoneValues), Zone);
     }
   }
   _ZoneDelegate[dart.implements] = () => [ZoneDelegate];
   dart.setSignature(_ZoneDelegate, {
     constructors: () => ({_ZoneDelegate: [_ZoneDelegate, [_Zone]]}),
     methods: () => ({
       handleUncaughtError: [dart.dynamic, [Zone, dart.dynamic, core.StackTrace]],
       run: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [])]],
       runUnary: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
       runBinary: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
@@ skipping 46 matching lines @@
       this[_createPeriodicTimer] = specification.createPeriodicTimer != null ? new _ZoneFunction(this, specification.createPeriodicTimer) : this.parent[_createPeriodicTimer];
       this[_print] = specification.print != null ? new _ZoneFunction(this, specification.print) : this.parent[_print];
       this[_fork] = specification.fork != null ? new _ZoneFunction(this, specification.fork) : this.parent[_fork];
       this[_handleUncaughtError] = specification.handleUncaughtError != null ? new _ZoneFunction(this, specification.handleUncaughtError) : this.parent[_handleUncaughtError];
     }
     get errorZone() {
       return this[_handleUncaughtError].zone;
     }
     runGuarded(f) {
       try {
-        return this.run(f);
+        return dart.dcall(this.run, f);
       } catch (e) {
         let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
+        return dart.dcall(this.handleUncaughtError, e, s);
       }
 
     }
     runUnaryGuarded(f, arg) {
       try {
-        return this.runUnary(f, arg);
+        return dart.dcall(this.runUnary, f, arg);
       } catch (e) {
         let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
+        return dart.dcall(this.handleUncaughtError, e, s);
       }
 
     }
     runBinaryGuarded(f, arg1, arg2) {
       try {
-        return this.runBinary(f, arg1, arg2);
+        return dart.dcall(this.runBinary, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
+        return dart.dcall(this.handleUncaughtError, e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      let registered = this.registerCallback(f);
+      let registered = dart.dcall(this.registerCallback, f);
       if (dart.notNull(runGuarded)) {
-        return dart.fn((() => this.runGuarded(registered)).bind(this));
+        return dart.fn((() => dart.dcall(this.runGuarded, registered)).bind(this));
       } else {
-        return dart.fn((() => this.run(registered)).bind(this));
+        return dart.fn((() => dart.dcall(this.run, registered)).bind(this));
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      let registered = this.registerUnaryCallback(f);
+      let registered = dart.dcall(this.registerUnaryCallback, f);
       if (dart.notNull(runGuarded)) {
-        return dart.fn((arg => this.runUnaryGuarded(registered, arg)).bind(this));
+        return dart.fn((arg => dart.dcall(this.runUnaryGuarded, registered, arg)).bind(this));
       } else {
-        return dart.fn((arg => this.runUnary(registered, arg)).bind(this));
+        return dart.fn((arg => dart.dcall(this.runUnary, registered, arg)).bind(this));
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      let registered = this.registerBinaryCallback(f);
+      let registered = dart.dcall(this.registerBinaryCallback, f);
       if (dart.notNull(runGuarded)) {
-        return dart.fn(((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this));
+        return dart.fn(((arg1, arg2) => dart.dcall(this.runBinaryGuarded, registered, arg1, arg2)).bind(this));
       } else {
-        return dart.fn(((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(this));
+        return dart.fn(((arg1, arg2) => dart.dcall(this.runBinary, registered, arg1, arg2)).bind(this));
       }
     }
     get(key) {
       let result = this[_map].get(key);
-      if (result != null || dart.notNull(this[_map].containsKey(key)))
+      if (result != null || dart.notNull(dart.dcall(this[_map].containsKey, key)))
         return result;
       if (this.parent != null) {
         let value = this.parent.get(key);
         if (value != null) {
           this[_map].set(key, value);
         }
         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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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 (dart.notNull(core.identical(implementationZone, _ROOT_ZONE)))
+      if (dart.notNull(dart.dcall(core.identical, implementationZone, _ROOT_ZONE)))
         return null;
-      let parentDelegate = _parentDelegate(dart.as(implementationZone, _Zone));
+      let parentDelegate = dart.dcall(_parentDelegate, implementationZone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       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);
+      let parentDelegate = dart.dcall(_parentDelegate, implementation.zone);
       return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, line);
     }
   }
   dart.setSignature(_CustomZone, {
     constructors: () => ({_CustomZone: [_CustomZone, [_Zone, ZoneSpecification, core.Map]]}),
     methods: () => ({
       runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
       runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
       runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
       bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {runGuarded: core.bool}],
       bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {runGuarded: core.bool}],
       bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {runGuarded: core.bool}],
       get: [dart.dynamic, [core.Object]],
       handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
       fork: [Zone, [], {specification: ZoneSpecification, zoneValues: core.Map}],
       run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
       runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
       runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
       registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
       registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
       registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
       errorCallback: [AsyncError, [core.Object, core.StackTrace]],
       scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
       createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
       print: [dart.void, [core.String]]
     })
   });
   function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
-    _schedulePriorityAsyncCallback(dart.fn(() => {
+    dart.dcall(_schedulePriorityAsyncCallback, dart.fn(() => {
       dart.throw(new _UncaughtAsyncError(error, stackTrace));
     }));
   }
   dart.fn(_rootHandleUncaughtError, dart.void, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
   function _rootRun(self, parent, zone, f) {
     if (dart.equals(Zone._current, zone))
       return f();
-    let old = Zone._enter(zone);
+    let old = dart.dcall(Zone._enter, zone);
     try {
       return f();
     } finally {
-      Zone._leave(old);
+      dart.dcall(Zone._leave, old);
     }
   }
   dart.fn(_rootRun, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
   function _rootRunUnary(self, parent, zone, f, arg) {
     if (dart.equals(Zone._current, zone))
       return dart.dcall(f, arg);
-    let old = Zone._enter(zone);
+    let old = dart.dcall(Zone._enter, zone);
     try {
       return dart.dcall(f, arg);
     } finally {
-      Zone._leave(old);
+      dart.dcall(Zone._leave, old);
     }
   }
   dart.fn(_rootRunUnary, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]);
   function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
     if (dart.equals(Zone._current, zone))
       return dart.dcall(f, arg1, arg2);
-    let old = Zone._enter(zone);
+    let old = dart.dcall(Zone._enter, zone);
     try {
       return dart.dcall(f, arg1, arg2);
     } finally {
-      Zone._leave(old);
+      dart.dcall(Zone._leave, old);
     }
   }
   dart.fn(_rootRunBinary, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]);
   function _rootRegisterCallback(self, parent, zone, f) {
     return f;
   }
   dart.fn(_rootRegisterCallback, ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
   function _rootRegisterUnaryCallback(self, parent, zone, f) {
     return f;
   }
   dart.fn(_rootRegisterUnaryCallback, ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]);
   function _rootRegisterBinaryCallback(self, parent, zone, f) {
     return f;
   }
   dart.fn(_rootRegisterBinaryCallback, ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
   function _rootErrorCallback(self, parent, zone, error, stackTrace) {
     return null;
   }
   dart.fn(_rootErrorCallback, AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]);
   function _rootScheduleMicrotask(self, parent, zone, f) {
-    if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
-      let hasErrorHandler = !dart.notNull(_ROOT_ZONE.inSameErrorZone(zone));
-      f = zone.bindCallback(f, {runGuarded: hasErrorHandler});
+    if (!dart.notNull(dart.dcall(core.identical, _ROOT_ZONE, zone))) {
+      let hasErrorHandler = !dart.notNull(dart.as(dart.dsend(_ROOT_ZONE, 'inSameErrorZone', zone), core.bool));
+      f = dart.dcall(zone.bindCallback, f, {runGuarded: hasErrorHandler});
     }
-    _scheduleAsyncCallback(f);
+    dart.dcall(_scheduleAsyncCallback, f);
   }
   dart.fn(_rootScheduleMicrotask, dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
   function _rootCreateTimer(self, parent, zone, duration, callback) {
-    if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
-      callback = zone.bindCallback(callback);
+    if (!dart.notNull(dart.dcall(core.identical, _ROOT_ZONE, zone))) {
+      callback = dart.dcall(zone.bindCallback, callback);
     }
-    return Timer._createTimer(duration, callback);
+    return dart.dcall(Timer._createTimer, duration, callback);
   }
   dart.fn(_rootCreateTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]);
   function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
-    if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
-      callback = dart.as(zone.bindUnaryCallback(callback), __CastType36);
+    if (!dart.notNull(dart.dcall(core.identical, _ROOT_ZONE, zone))) {
+      callback = dart.as(dart.dcall(zone.bindUnaryCallback, callback), __CastType17);
     }
-    return Timer._createPeriodicTimer(duration, callback);
+    return dart.dcall(Timer._createPeriodicTimer, duration, callback);
   }
   dart.fn(_rootCreatePeriodicTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]);
   function _rootPrint(self, parent, zone, line) {
-    _internal.printToConsole(line);
+    dart.dcall(_internal.printToConsole, line);
   }
   dart.fn(_rootPrint, dart.void, [Zone, ZoneDelegate, Zone, core.String]);
   function _printToZone(line) {
-    Zone.current.print(line);
+    dart.dcall(Zone.current.print, line);
   }
   dart.fn(_printToZone, dart.void, [core.String]);
   function _rootFork(self, parent, zone, specification, zoneValues) {
     _internal.printToZone = _printToZone;
     if (specification == null) {
       specification = dart.const(ZoneSpecification.new());
     } else if (!dart.is(specification, _ZoneSpecification)) {
       dart.throw(new core.ArgumentError("ZoneSpecifications must be instantiated" + " with the provided constructor."));
     }
     let valueMap = null;
@@ skipping 60 matching lines @@
   });
   function runZoned(body, opts) {
     let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
     let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
     let onError = opts && 'onError' in opts ? opts.onError : null;
     let errorHandler = null;
     if (onError != null) {
       errorHandler = dart.fn((self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
-            return self.parent.runBinary(onError, error, stackTrace);
+            return dart.dcall(self.parent.runBinary, onError, error, stackTrace);
           }
-          return self.parent.runUnary(dart.as(onError, __CastType38), error);
+          return dart.dcall(self.parent.runUnary, onError, error);
         } catch (e) {
           let s = dart.stackTrace(e);
-          if (dart.notNull(core.identical(e, error))) {
-            return parent.handleUncaughtError(zone, error, stackTrace);
+          if (dart.notNull(dart.dcall(core.identical, e, error))) {
+            return dart.dcall(parent.handleUncaughtError, zone, error, stackTrace);
           } else {
-            return parent.handleUncaughtError(zone, e, s);
+            return dart.dcall(parent.handleUncaughtError, zone, e, s);
           }
         }
 
       }, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
     }
     if (zoneSpecification == null) {
       zoneSpecification = ZoneSpecification.new({handleUncaughtError: errorHandler});
     } else if (errorHandler != null) {
       zoneSpecification = ZoneSpecification.from(zoneSpecification, {handleUncaughtError: errorHandler});
     }
-    let zone = Zone.current.fork({specification: zoneSpecification, zoneValues: zoneValues});
+    let zone = dart.dcall(Zone.current.fork, {specification: zoneSpecification, zoneValues: zoneValues});
     if (onError != null) {
-      return zone.runGuarded(body);
+      return dart.dcall(zone.runGuarded, body);
     } else {
-      return zone.run(body);
+      return dart.dcall(zone.run, body);
     }
   }
   dart.fn(runZoned, dart.dynamic, [dart.functionType(dart.dynamic, [])], {zoneValues: core.Map, zoneSpecification: ZoneSpecification, onError: core.Function});
-  let __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.void, [Timer]));
-  let __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType17 = dart.typedef('__CastType17', () => dart.functionType(dart.void, [Timer]));
   dart.copyProperties(exports, {
     get _hasDocument() {
-      return typeof document == 'object';
+      return dart.equals(typeof document, 'object');
     }
   });
   // Exports:
   exports.AsyncError = AsyncError;
   exports.Stream$ = Stream$;
   exports.Stream = Stream;
   exports.DeferredLibrary = DeferredLibrary;
   exports.DeferredLoadException = DeferredLoadException;
   exports.Future$ = Future$;
   exports.Future = Future;
@@ skipping 32 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;
 });