Handle dynamic as bottom inside of function type reps

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',
   'dart/_js_helper'
 ], function(exports, dart, core, _internal, collection, _isolate_helper, _js_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, core.Object, [core.Function, core.Object, core.StackTrace]);
+  dart.fn(_invokeErrorHandler, dart.dynamic, [core.Function, core.Object, core.StackTrace]);
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return zone.registerBinaryCallback(errorHandler);
     } else {
       return zone.registerUnaryCallback(dart.as(errorHandler, __CastType0));
     }
   }
-  dart.fn(_registerErrorHandler, () => dart.functionType(core.Function, [core.Function, Zone]));
+  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);
     }
   }
   AsyncError[dart.implements] = () => [core.Error];
   dart.setSignature(AsyncError, {
-    constructors: () => ({AsyncError: [AsyncError, [core.Object, core.StackTrace]]})
+    constructors: () => ({AsyncError: [AsyncError, [dart.dynamic, core.StackTrace]]})
   });
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _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, [core.Object, core.StackTrace]]}),
-    statics: () => ({_getBestStackTrace: [core.StackTrace, [core.Object, core.StackTrace]]}),
+    constructors: () => ({_UncaughtAsyncError: [_UncaughtAsyncError, [dart.dynamic, core.StackTrace]]}),
+    statics: () => ({_getBestStackTrace: [core.StackTrace, [dart.dynamic, core.StackTrace]]}),
     names: ['_getBestStackTrace']
   });
-  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [dart.bottom]));
+  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]();
         }), {onError: dart.fn((error, stackTrace) => {
             controller[_addError](error, dart.as(stackTrace, core.StackTrace));
             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, [core.Object]);
+          computation = dart.fn(i => null, dart.bottom, [dart.dynamic]);
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         let sendEvent = () => {
           watch.reset();
           let data = computation((() => {
             let x = computationCount;
             computationCount = dart.notNull(x) + 1;
             return x;
           })());
           controller.add(data);
         };
         dart.fn(sendEvent, dart.void, []);
         let startPeriodicTimer = () => {
           dart.assert(timer == null);
           timer = Timer.periodic(period, dart.fn(timer => {
             sendEvent();
-          }, core.Object, [Timer]));
+          }, dart.dynamic, [Timer]));
         };
         dart.fn(startPeriodicTimer, dart.void, []);
         controller = StreamController$(T).new({sync: true, onListen: dart.fn(() => {
             watch.start();
             startPeriodicTimer();
           }), onPause: dart.fn(() => {
             timer.cancel();
             timer = null;
             watch.stop();
           }), onResume: dart.fn(() => {
             dart.assert(timer == null);
             let elapsed = watch.elapsed;
             watch.start();
             timer = Timer.new(period['-'](elapsed), dart.fn(() => {
               timer = null;
               startPeriodicTimer();
               sendEvent();
             }));
           }), onCancel: dart.fn(() => {
             if (timer != null)
               timer.cancel();
             timer = null;
           })});
         return controller.stream;
       }
       static eventTransformed(source, mapSink) {
-        return new (_BoundSinkStream$(core.Object, T))(source, dart.as(mapSink, _SinkMapper));
+        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])));
       }
       where(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
-        dart.as(convert, dart.functionType(core.Object, [T]));
-        return new (_MapStream$(T, core.Object))(this, convert);
+        dart.as(convert, dart.functionType(dart.dynamic, [T]));
+        return new (_MapStream$(T, dart.dynamic))(this, convert);
       }
       asyncMap(convert) {
-        dart.as(convert, dart.functionType(core.Object, [T]));
+        dart.as(convert, dart.functionType(dart.dynamic, [T]));
         let controller = null;
         let subscription = null;
         let onListen = () => {
           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 => {
             dart.as(event, T);
             let newValue = null;
             try {
               newValue = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (dart.is(newValue, Future)) {
               subscription.pause();
               dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', dart.bind(subscription, 'resume'));
             } else {
               controller.add(newValue);
             }
-          }, core.Object, [T]), {onError: dart.as(addError, core.Function), onDone: dart.bind(controller, 'close')});
+          }, dart.dynamic, [T]), {onError: dart.as(addError, core.Function), onDone: dart.bind(controller, 'close')});
         };
         dart.fn(onListen, dart.void, []);
         if (dart.notNull(this.isBroadcast)) {
           controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
             }), sync: true});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
             }), onResume: dart.fn(() => {
@@ skipping 19 matching lines @@
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (newStream != null) {
               subscription.pause();
               controller.addStream(newStream).whenComplete(dart.bind(subscription, 'resume'));
             }
-          }, core.Object, [T]), {onError: dart.as(eventSink[_addError], core.Function), onDone: dart.bind(controller, 'close')});
+          }, dart.dynamic, [T]), {onError: dart.as(eventSink[_addError], core.Function), onDone: dart.bind(controller, 'close')});
         };
         dart.fn(onListen, dart.void, []);
         if (dart.notNull(this.isBroadcast)) {
           controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
             }), sync: true});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
             }), onResume: dart.fn(() => {
               subscription.resume();
             }), onCancel: dart.fn(() => {
               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.bottom]));
+        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, core.Object))(this, convert);
+        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, [core.Object]));
+        return streamConsumer.addStream(this).then(dart.fn(_ => streamConsumer.close(), Future, [dart.dynamic]));
       }
       transform(streamTransformer) {
-        dart.as(streamTransformer, StreamTransformer$(T, core.Object));
+        dart.as(streamTransformer, StreamTransformer$(T, dart.dynamic));
         return 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 => {
           dart.as(element, T);
           if (dart.notNull(seenFirst)) {
             _runUserCode(dart.fn(() => combine(value, element), T, []), dart.fn(newValue => {
               dart.as(newValue, T);
               value = newValue;
-            }, core.Object, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
+            }, dart.dynamic, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
           } else {
             value = element;
             seenFirst = true;
           }
-        }, core.Object, [T]), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
+        }, dart.dynamic, [T]), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
             if (!dart.notNull(seenFirst)) {
               try {
                 throw _internal.IterableElementError.noElement();
               } catch (e) {
                 let s = dart.stackTrace(e);
                 _completeWithErrorCallback(result, e, s);
               }
 
             } else {
               result[_complete](value);
             }
           }), cancelOnError: true});
         return result;
       }
       fold(initialValue, combine) {
-        dart.as(combine, dart.functionType(core.Object, [dart.bottom, T]));
+        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 => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => dart.dcall(combine, value, element)), dart.fn(newValue => {
             value = newValue;
-          }), dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
-        }, core.Object, [T]), {onError: dart.fn((e, st) => {
+          }), dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.fn((e, st) => {
             result[_completeError](e, dart.as(st, core.StackTrace));
           }), onDone: dart.fn(() => {
             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 => {
           dart.as(element, T);
           if (!dart.notNull(first)) {
             buffer.write(separator);
           }
           first = false;
           try {
             buffer.write(element);
           } catch (e) {
             let s = dart.stackTrace(e);
             _cancelAndErrorWithReplacement(subscription, result, e, s);
           }
 
-        }, core.Object, [T]), {onError: dart.fn(e => {
+        }, dart.dynamic, [T]), {onError: dart.fn(e => {
             result[_completeError](e);
           }), onDone: dart.fn(() => {
             result[_complete](dart.toString(buffer));
           }), cancelOnError: true});
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => dart.equals(element, needle), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, true);
             }
-          }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             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 => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => action(element), dart.void, []), dart.fn(_ => {
-          }), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+          }), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             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 => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
             if (!dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, false);
             }
-          }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             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 => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, true);
             }
-          }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](false);
           }), cancelOnError: true});
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
         this.listen(dart.fn(_ => {
           count = dart.notNull(count) + 1;
         }), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
@@ skipping 10 matching lines @@
             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.as(data, T);
           result[dartx.add](data);
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             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.as(data, T);
           result.add(data);
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](result);
           }), cancelOnError: true});
         return future;
       }
       drain(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
       }
       take(count) {
@@ skipping 15 matching lines @@
           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 => {
           dart.as(value, T);
           _cancelAndValue(subscription, future, value);
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _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 => {
           dart.as(value, T);
           foundResult = true;
           result = value;
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
@@ skipping 13 matching lines @@
               throw _internal.IterableElementError.tooMany();
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _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 => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, value);
             }
-          }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (defaultValue != null) {
               _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _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 => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               foundResult = true;
               result = value;
             }
-          }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             if (defaultValue != null) {
               _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
@@ skipping 21 matching lines @@
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
-          }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       elementAt(index) {
         if (!(typeof index == 'number') || dart.notNull(index) < 0)
           throw new core.ArgumentError(index);
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = dart.notNull(elementIndex) + 1;
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_completeError](core.RangeError.index(index, this, "index", null, elementIndex));
           }), 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;
         let onData = event => {
           dart.as(event, T);
           timer.cancel();
           controller.add(event);
           timer = zone.createTimer(timeLimit, dart.as(timeout, __CastType17));
         };
         dart.fn(onData, dart.void, [T]);
         let onError = (error, stackTrace) => {
           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.fn(onError, dart.void, [core.Object, core.StackTrace]);
+        dart.fn(onError, dart.void, [dart.dynamic, core.StackTrace]);
         let onDone = () => {
           timer.cancel();
           controller.close();
         };
         dart.fn(onDone, dart.void, []);
         let onListen = () => {
           zone = Zone.current;
           if (onTimeout == null) {
             timeout = dart.fn(() => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
@@ skipping 32 matching lines @@
       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])]],
         eventTransformed: [Stream$(T), [Stream$(), dart.functionType(EventSink, [EventSink$(T)])]]
       }),
       methods: () => ({
         asBroadcastStream: [Stream$(T), [], {onListen: dart.functionType(dart.void, [StreamSubscription$(T)]), onCancel: dart.functionType(dart.void, [StreamSubscription$(T)])}],
         where: [Stream$(T), [dart.functionType(core.bool, [T])]],
-        map: [Stream$(), [dart.functionType(core.Object, [T])]],
-        asyncMap: [Stream$(), [dart.functionType(core.Object, [T])]],
+        map: [Stream$(), [dart.functionType(dart.dynamic, [T])]],
+        asyncMap: [Stream$(), [dart.functionType(dart.dynamic, [T])]],
         asyncExpand: [Stream$(), [dart.functionType(Stream$(), [T])]],
-        handleError: [Stream$(T), [core.Function], {test: dart.functionType(core.bool, [dart.bottom])}],
+        handleError: [Stream$(T), [core.Function], {test: dart.functionType(core.bool, [dart.dynamic])}],
         expand: [Stream$(), [dart.functionType(core.Iterable, [T])]],
         pipe: [Future, [StreamConsumer$(T)]],
-        transform: [Stream$(), [StreamTransformer$(T, core.Object)]],
+        transform: [Stream$(), [StreamTransformer$(T, dart.dynamic)]],
         reduce: [Future$(T), [dart.functionType(T, [T, T])]],
-        fold: [Future, [core.Object, dart.functionType(core.Object, [dart.bottom, T])]],
+        fold: [Future, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, T])]],
         join: [Future$(core.String), [], [core.String]],
         contains: [Future$(core.bool), [core.Object]],
         forEach: [Future, [dart.functionType(dart.void, [T])]],
         every: [Future$(core.bool), [dart.functionType(core.bool, [T])]],
         any: [Future$(core.bool), [dart.functionType(core.bool, [T])]],
         toList: [Future$(core.List$(T)), []],
         toSet: [Future$(core.Set$(T)), []],
-        drain: [Future, [], [core.Object]],
+        drain: [Future, [], [dart.dynamic]],
         take: [Stream$(T), [core.int]],
         takeWhile: [Stream$(T), [dart.functionType(core.bool, [T])]],
         skip: [Stream$(T), [core.int]],
         skipWhile: [Stream$(T), [dart.functionType(core.bool, [T])]],
         distinct: [Stream$(T), [], [dart.functionType(core.bool, [T, T])]],
         firstWhere: [Future, [dart.functionType(core.bool, [T])], {defaultValue: dart.functionType(core.Object, [])}],
         lastWhere: [Future, [dart.functionType(core.bool, [T])], {defaultValue: dart.functionType(core.Object, [])}],
         singleWhere: [Future$(T), [dart.functionType(core.bool, [T])]],
         elementAt: [Future$(T), [core.int]],
         timeout: [Stream$(), [core.Duration], {onTimeout: dart.functionType(dart.void, [EventSink])}]
@@ skipping 431 matching lines @@
       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])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
-        asFuture: [Future, [], [core.Object]],
+        asFuture: [Future, [], [dart.dynamic]],
         [_cancel]: [dart.void, []],
         [_incrementPauseCount]: [dart.void, []],
         [_decrementPauseCount]: [dart.void, []],
         [_add]: [dart.void, [T]],
         [_addError]: [dart.void, [core.Object, core.StackTrace]],
         [_close]: [dart.void, []],
         [_onPause]: [dart.void, []],
         [_onResume]: [dart.void, []],
         [_onCancel]: [Future, []],
         [_addPending]: [dart.void, [_DelayedEvent]],
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []],
-        [_guardCallback]: [dart.void, [core.Object]],
+        [_guardCallback]: [dart.void, [dart.dynamic]],
         [_checkState]: [dart.void, [core.bool]]
       })
     });
     return _BufferingStreamSubscription;
   });
   let _BufferingStreamSubscription = _BufferingStreamSubscription$();
   let _recordCancel = Symbol('_recordCancel');
   let _recordPause = Symbol('_recordPause');
   let _recordResume = Symbol('_recordResume');
   let _ControllerSubscription$ = dart.generic(function(T) {
@@ skipping 336 matching lines @@
           subscription[_add](data);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
           if (dart.notNull(this[_isEmpty])) {
             this[_callOnCancel]();
           }
           return;
         }
         this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_add](data);
-        }, core.Object, [_BufferingStreamSubscription$(T)]));
+        }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
       }
       [_sendError](error, stackTrace) {
         if (dart.notNull(this[_isEmpty]))
           return;
         this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_addError](error, stackTrace);
-        }, core.Object, [_BufferingStreamSubscription$(T)]));
+        }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
           this[_forEachListener](dart.as(dart.fn(subscription => {
             dart.as(subscription, _BroadcastSubscription$(T));
             subscription[_close]();
-          }, core.Object, [_BroadcastSubscription$(T)]), __CastType2));
+          }, dart.dynamic, [_BroadcastSubscription$(T)]), __CastType2));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     dart.setSignature(_SyncBroadcastStreamController, {
       constructors: () => ({_SyncBroadcastStreamController: [_SyncBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
@@ skipping 159 matching lines @@
       }
     }
     _DoneSubscription[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_DoneSubscription, {
       methods: () => ({
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
-        [_resume]: [dart.void, [core.Object]],
+        [_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;
@@ skipping 95 matching lines @@
             let s = dart.stackTrace(e);
             _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.bottom]));
+        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;
         let 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));
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
           } else if (remaining == 0 && !dart.notNull(eagerError)) {
             result[_completeError](error, stackTrace);
           }
         };
-        dart.fn(handleError, dart.void, [core.Object, core.Object]);
+        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 => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
               values[dartx.set](pos, value);
               if (remaining == 0) {
                 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);
               }
             }
-          }, core.Object, [core.Object]), {onError: handleError});
+          }, 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(core.Object, [dart.bottom]));
+        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 false;
-          return Future$().sync(dart.fn(() => dart.dcall(f, iterator.current))).then(dart.fn(_ => true, core.bool, [core.Object]));
+          return 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(core.Object, []));
+        dart.as(f, dart.functionType(dart.dynamic, []));
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback(dart.fn(keepGoing => {
           if (dart.notNull(keepGoing)) {
             Future$().sync(f).then(dart.as(nextIteration, __CastType4), {onError: dart.bind(doneSignal, _completeError)});
           } else {
             doneSignal[_complete](null);
           }
-        }, core.Object, [core.bool]), {runGuarded: true});
+        }, dart.dynamic, [core.bool]), {runGuarded: true});
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.setSignature(Future, {
       constructors: () => ({
-        new: [Future$(T), [dart.functionType(core.Object, [])]],
-        microtask: [Future$(T), [dart.functionType(core.Object, [])]],
-        sync: [Future$(T), [dart.functionType(core.Object, [])]],
-        value: [Future$(T), [], [core.Object]],
+        new: [Future$(T), [dart.functionType(dart.dynamic, [])]],
+        microtask: [Future$(T), [dart.functionType(dart.dynamic, [])]],
+        sync: [Future$(T), [dart.functionType(dart.dynamic, [])]],
+        value: [Future$(T), [], [dart.dynamic]],
         error: [Future$(T), [core.Object], [core.StackTrace]],
         delayed: [Future$(T), [core.Duration], [dart.functionType(T, [])]]
       }),
       statics: () => ({
-        wait: [Future$(core.List), [core.Iterable$(Future$())], {eagerError: core.bool, cleanUp: dart.functionType(dart.void, [dart.bottom])}],
-        forEach: [Future$(), [core.Iterable, dart.functionType(core.Object, [dart.bottom])]],
-        doWhile: [Future$(), [dart.functionType(core.Object, [])]]
+        wait: [Future$(core.List), [core.Iterable$(Future$())], {eagerError: core.bool, cleanUp: dart.functionType(dart.void, [dart.dynamic])}],
+        forEach: [Future$(), [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic])]],
+        doWhile: [Future$(), [dart.functionType(dart.dynamic, [])]]
       }),
       names: ['wait', 'forEach', 'doWhile']
     });
     return Future;
   });
   let Future = Future$();
   dart.defineLazyProperties(Future, {
     get _nullFuture() {
       return new _Future.immediate(null);
     }
@@ skipping 37 matching lines @@
   });
   let Completer = Completer$();
   function _completeWithErrorCallback(result, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     result[_completeError](error, dart.as(stackTrace, core.StackTrace));
   }
-  dart.fn(_completeWithErrorCallback, () => dart.functionType(dart.void, [_Future, core.Object, core.Object]));
+  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(core.Object, [dart.bottom]));
+  let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let _FutureOnValue$ = dart.generic(function(T) {
-    let _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType(core.Object, [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.bottom]));
-  let _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(core.Object, []));
+  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);
         if (!dart.notNull(this.future[_mayComplete]))
@@ skipping 28 matching lines @@
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
         this.future[_asyncComplete](value);
       }
       [_completeError](error, stackTrace) {
         this.future[_asyncCompleteError](error, stackTrace);
       }
     }
     dart.setSignature(_AsyncCompleter, {
       methods: () => ({
-        complete: [dart.void, [], [core.Object]],
+        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]))
           throw new core.StateError("Future already completed");
         this.future[_complete](value);
       }
       [_completeError](error, stackTrace) {
         this.future[_completeError](error, stackTrace);
       }
     }
     dart.setSignature(_SyncCompleter, {
       methods: () => ({
-        complete: [dart.void, [], [core.Object]],
+        complete: [dart.void, [], [dart.dynamic]],
         [_completeError]: [dart.void, [core.Object, core.StackTrace]]
       })
     });
     return _SyncCompleter;
   });
   let _SyncCompleter = _SyncCompleter$();
   let _nextListener = Symbol('_nextListener');
   let _onValue = Symbol('_onValue');
   let _errorTest = Symbol('_errorTest');
   let _whenCompleteAction = Symbol('_whenCompleteAction');
@@ skipping 130 matching lines @@
       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(core.Object, [T]));
+        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 (onError != null) {
             onError = _registerErrorHandler(onError, result[_zone]);
           }
         }
         this[_addListener](new _FutureListener.then(result, f, onError));
         return result;
       }
       catchError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
-        dart.as(test, dart.functionType(core.bool, [dart.bottom]));
+        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 (test != null)
             test = dart.as(result[_zone].registerUnaryCallback(test), __CastType8);
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
-        dart.as(action, dart.functionType(core.Object, []));
+        dart.as(action, dart.functionType(dart.dynamic, []));
         let result = new (_Future$(T))();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           action = result[_zone].registerCallback(action);
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
         return dart.as(result, Future$(T));
       }
       asStream() {
         return Stream$(T).fromFuture(this);
       }
@@ skipping 53 matching lines @@
         dart.assert(!dart.is(source, _Future$()));
         target[_isChained] = true;
         source.then(dart.fn(value => {
           dart.assert(target[_isChained]);
           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));
-          }, core.Object, [core.Object], [core.Object])});
+          }, 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);
         } else {
           source[_addListener](listener);
@@ skipping 166 matching lines @@
                 dart.dsend(completeResult, 'then', dart.fn(ignored => {
                   _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));
-                  }, core.Object, [core.Object], [core.Object])});
+                  }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
               }
             };
             dart.fn(handleWhenCompleteCallback, dart.void, []);
             if (!dart.notNull(hasError)) {
               if (dart.notNull(listener.handlesValue)) {
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
@@ skipping 28 matching lines @@
             result[_setValue](listenerValueOrError);
           } else {
             let asyncError = dart.as(listenerValueOrError, AsyncError);
             result[_setErrorObject](asyncError);
           }
           source = result;
         }
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
-        dart.as(onTimeout, dart.functionType(core.Object, []));
+        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));
           }));
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
           timer = Timer.new(timeLimit, dart.fn(() => {
             try {
               result[_complete](zone.run(onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
               result[_completeError](e, s);
             }
 
           }));
         }
         this.then(dart.fn(v => {
           dart.as(v, T);
           if (dart.notNull(timer.isActive)) {
             timer.cancel();
             result[_completeWithValue](v);
           }
-        }, core.Object, [T]), {onError: dart.fn((e, s) => {
+        }, dart.dynamic, [T]), {onError: dart.fn((e, s) => {
             if (dart.notNull(timer.isActive)) {
               timer.cancel();
               result[_completeError](e, dart.as(s, core.StackTrace));
             }
           })});
         return result;
       }
     }
     _Future[dart.implements] = () => [Future$(T)];
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
     dart.setSignature(_Future, {
       constructors: () => ({
         _Future: [_Future$(T), []],
-        immediate: [_Future$(T), [core.Object]],
-        immediateError: [_Future$(T), [core.Object], [core.StackTrace]]
+        immediate: [_Future$(T), [dart.dynamic]],
+        immediateError: [_Future$(T), [dart.dynamic], [core.StackTrace]]
       }),
       methods: () => ({
-        then: [Future, [dart.functionType(core.Object, [T])], {onError: core.Function}],
-        catchError: [Future, [core.Function], {test: dart.functionType(core.bool, [dart.bottom])}],
-        whenComplete: [Future$(T), [dart.functionType(core.Object, [])]],
+        then: [Future, [dart.functionType(dart.dynamic, [T])], {onError: core.Function}],
+        catchError: [Future, [core.Function], {test: dart.functionType(core.bool, [dart.dynamic])}],
+        whenComplete: [Future$(T), [dart.functionType(dart.dynamic, [])]],
         asStream: [Stream$(T), []],
         [_markPendingCompletion]: [dart.void, []],
         [_setValue]: [dart.void, [T]],
         [_setErrorObject]: [dart.void, [AsyncError]],
         [_setError]: [dart.void, [core.Object, core.StackTrace]],
         [_addListener]: [dart.void, [_FutureListener]],
         [_removeListeners]: [_FutureListener, []],
-        [_complete]: [dart.void, [core.Object]],
-        [_completeWithValue]: [dart.void, [core.Object]],
-        [_completeError]: [dart.void, [core.Object], [core.StackTrace]],
-        [_asyncComplete]: [dart.void, [core.Object]],
-        [_asyncCompleteError]: [dart.void, [core.Object, core.StackTrace]],
-        timeout: [Future, [core.Duration], {onTimeout: dart.functionType(core.Object, [])}]
+        [_complete]: [dart.void, [dart.dynamic]],
+        [_completeWithValue]: [dart.void, [dart.dynamic]],
+        [_completeError]: [dart.void, [dart.dynamic], [core.StackTrace]],
+        [_asyncComplete]: [dart.void, [dart.dynamic]],
+        [_asyncCompleteError]: [dart.void, [dart.dynamic, core.StackTrace]],
+        timeout: [Future, [core.Duration], {onTimeout: dart.functionType(dart.dynamic, [])}]
       }),
       statics: () => ({
         _chainForeignFuture: [dart.void, [Future, _Future$()]],
         _chainCoreFuture: [dart.void, [_Future$(), _Future$()]],
         _propagateToListeners: [dart.void, [_Future$(), _FutureListener]]
       }),
       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(core.Object, [T]));
+    let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(dart.dynamic, [T]));
     return __CastType6;
   });
   let __CastType6 = __CastType6$();
-  let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.bottom]));
-  let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(core.Object, [dart.bottom]));
+  let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.dynamic]));
+  let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.dynamic, [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]]})
   });
@@ skipping 29 matching lines @@
       exports._nextCallback = exports._lastCallback = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
       if (!dart.notNull(exports._isInCallbackLoop)) {
         _AsyncRun._scheduleImmediate(_asyncRunCallback);
       }
     } else {
       let newEntry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
       exports._lastCallback.next = newEntry;
       exports._lastCallback = newEntry;
     }
   }
-  dart.fn(_scheduleAsyncCallback, dart.void, [core.Object]);
+  dart.fn(_scheduleAsyncCallback, dart.void, [dart.dynamic]);
   function _schedulePriorityAsyncCallback(callback) {
     let entry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
     if (exports._nextCallback == null) {
       _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, [core.Object]);
+  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);
       return;
     }
     Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
   }
   dart.fn(scheduleMicrotask, dart.void, [dart.functionType(dart.void, [])]);
   class _AsyncRun extends core.Object {
     static _scheduleImmediate(callback) {
@@ skipping 15 matching lines @@
         };
         dart.fn(internalCallback);
         ;
         let observer = new self.MutationObserver(_js_helper.convertDartClosureToJS(internalCallback, 1));
         observer.observe(div, {childList: true});
         return dart.fn(callback => {
           dart.assert(storedCallback == null);
           _isolate_helper.enterJsAsync();
           storedCallback = callback;
           div.firstChild ? div.removeChild(span) : div.appendChild(span);
-        }, core.Object, [dart.functionType(dart.void, [])]);
+        }, dart.dynamic, [dart.functionType(dart.void, [])]);
       } else if (self.setImmediate != null) {
         return _AsyncRun._scheduleImmediateWithSetImmediate;
       }
       return _AsyncRun._scheduleImmediateWithTimer;
     }
     static _scheduleImmediateJsOverride(callback) {
       let internalCallback = () => {
         _isolate_helper.leaveJsAsync();
         callback();
       };
@@ skipping 135 matching lines @@
       }
       close() {
         this[_sink].close();
       }
     }
     _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_ControllerEventSinkWrapper, {
       constructors: () => ({_ControllerEventSinkWrapper: [_ControllerEventSinkWrapper$(T), [EventSink]]}),
       methods: () => ({
         add: [dart.void, [T]],
-        addError: [dart.void, [core.Object], [core.StackTrace]],
+        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(core.Object, [dart.bottom, core.StackTrace]));
+  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 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));
         }
         return dart.notNull(sync) ? new (_SyncStreamController$(T))(onListen, onPause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
       }
       static broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         return dart.notNull(sync) ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
       }
     }
     StreamController[dart.implements] = () => [StreamSink$(T)];
     dart.setSignature(StreamController, {
       constructors: () => ({
-        new: [StreamController$(T), [], {onListen: dart.functionType(dart.void, []), onPause: dart.functionType(dart.void, []), onResume: dart.functionType(dart.void, []), onCancel: dart.functionType(core.Object, []), sync: core.bool}],
+        new: [StreamController$(T), [], {onListen: dart.functionType(dart.void, []), onPause: dart.functionType(dart.void, []), onResume: dart.functionType(dart.void, []), onCancel: dart.functionType(dart.dynamic, []), sync: core.bool}],
         broadcast: [StreamController$(T), [], {onListen: dart.functionType(dart.void, []), onCancel: dart.functionType(dart.void, []), sync: core.bool}]
       })
     });
     return StreamController;
   });
   let StreamController = StreamController$();
   let _StreamControllerLifecycle$ = dart.generic(function(T) {
     class _StreamControllerLifecycle extends core.Object {
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
@@ skipping 327 matching lines @@
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
       _AsyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
         this[_onPause] = onPause;
         this[_onResume] = onResume;
         this[_onCancel] = onCancel;
         super._StreamController();
       }
     }
     dart.setSignature(_AsyncStreamController, {
-      constructors: () => ({_AsyncStreamController: [_AsyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(core.Object, [])]]})
+      constructors: () => ({_AsyncStreamController: [_AsyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.dynamic, [])]]})
     });
     return _AsyncStreamController;
   });
   let _AsyncStreamController = _AsyncStreamController$();
   let _SyncStreamController$ = dart.generic(function(T) {
     class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T)) {
       _SyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
         this[_onPause] = onPause;
         this[_onResume] = onResume;
         this[_onCancel] = onCancel;
         super._StreamController();
       }
     }
     dart.setSignature(_SyncStreamController, {
-      constructors: () => ({_SyncStreamController: [_SyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(core.Object, [])]]})
+      constructors: () => ({_SyncStreamController: [_SyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.dynamic, [])]]})
     });
     return _SyncStreamController;
   });
   let _SyncStreamController = _SyncStreamController$();
   class _NoCallbacks extends core.Object {
     get [_onListen]() {
       return null;
     }
     get [_onPause]() {
       return null;
     }
     get [_onResume]() {
       return null;
     }
     get [_onCancel]() {
       return null;
     }
   }
   class _NoCallbackAsyncStreamController extends dart.mixin(_StreamController, _AsyncStreamControllerDispatch, _NoCallbacks) {}
   class _NoCallbackSyncStreamController extends dart.mixin(_StreamController, _SyncStreamControllerDispatch, _NoCallbacks) {}
-  let _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(core.Object, []));
+  let _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(dart.dynamic, []));
   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);
@@ skipping 45 matching lines @@
   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});
       }
       static makeErrorHandler(controller) {
         return dart.fn((e, s) => {
           controller[_addError](e, s);
           controller[_close]();
-        }, core.Object, [core.Object, core.StackTrace]);
+        }, dart.dynamic, [dart.dynamic, core.StackTrace]);
       }
       pause() {
         this.addSubscription.pause();
       }
       resume() {
         this.addSubscription.resume();
       }
       cancel() {
         let cancel = this.addSubscription.cancel();
         if (cancel == null) {
           this.addStreamFuture[_asyncComplete](null);
           return null;
         }
         return cancel.whenComplete(dart.fn(() => {
           this.addStreamFuture[_asyncComplete](null);
         }));
       }
       complete() {
         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: [core.Object, [_EventSink]]}),
+      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.setSignature(_StreamControllerAddStreamState, {
-      constructors: () => ({_StreamControllerAddStreamState: [_StreamControllerAddStreamState$(T), [_StreamController, core.Object, Stream, core.bool]]})
+      constructors: () => ({_StreamControllerAddStreamState: [_StreamControllerAddStreamState$(T), [_StreamController, dart.dynamic, Stream, core.bool]]})
     });
     return _StreamControllerAddStreamState;
   });
   let _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
   let _EventSink$ = dart.generic(function(T) {
     class _EventSink extends core.Object {}
     return _EventSink;
   });
   let _EventSink = _EventSink$();
   let _EventDispatch$ = dart.generic(function(T) {
@@ skipping 126 matching lines @@
   });
   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, [core.Object]);
+  dart.fn(_nullDataHandler, dart.void, [dart.dynamic]);
   function _nullErrorHandler(error, stackTrace) {
     if (stackTrace === void 0)
       stackTrace = null;
     Zone.current.handleUncaughtError(error, stackTrace);
   }
-  dart.fn(_nullErrorHandler, dart.void, [core.Object], [core.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;
@@ skipping 21 matching lines @@
     _DelayedError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
       super._DelayedEvent();
     }
     perform(dispatch) {
       dispatch[_sendError](this.error, this.stackTrace);
     }
   }
   dart.setSignature(_DelayedError, {
-    constructors: () => ({_DelayedError: [_DelayedError, [core.Object, core.StackTrace]]}),
+    constructors: () => ({_DelayedError: [_DelayedError, [dart.dynamic, core.StackTrace]]}),
     methods: () => ({perform: [dart.void, [_EventDispatch]]})
   });
   class _DelayedDone extends core.Object {
     _DelayedDone() {
     }
     perform(dispatch) {
       dispatch[_sendDone]();
     }
     get next() {
       return null;
@@ skipping 149 matching lines @@
     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, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
-        asFuture: [Future, [], [core.Object]],
+        asFuture: [Future, [], [dart.dynamic]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _DoneStreamSubscription;
   });
   let _DoneStreamSubscription = _DoneStreamSubscription$();
   _DoneStreamSubscription._DONE_SENT = 1;
   _DoneStreamSubscription._SCHEDULED = 2;
   _DoneStreamSubscription._PAUSED = 4;
   let _source = Symbol('_source');
@@ skipping 128 matching lines @@
     _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_BroadcastSubscriptionWrapper, {
       constructors: () => ({_BroadcastSubscriptionWrapper: [_BroadcastSubscriptionWrapper$(T), [_AsBroadcastStream]]}),
       methods: () => ({
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
-        asFuture: [Future, [], [core.Object]]
+        asFuture: [Future, [], [dart.dynamic]]
       })
     });
     return _BroadcastSubscriptionWrapper;
   });
   let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$();
   let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
   let _clear = Symbol('_clear');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends core.Object {
@@ skipping 121 matching lines @@
   _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 __CastType20 = __CastType20$();
-  let __CastType22 = dart.typedef('__CastType22', () => dart.functionType(core.Object, [dart.bottom, dart.bottom]));
-  let __CastType25 = dart.typedef('__CastType25', () => dart.functionType(core.Object, [dart.bottom]));
+  let __CastType22 = dart.typedef('__CastType22', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
+  let __CastType25 = dart.typedef('__CastType25', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   function _runUserCode(userCode, onSuccess, onError) {
     try {
       dart.dcall(onSuccess, userCode());
     } catch (e) {
       let s = dart.stackTrace(e);
       let replacement = Zone.current.errorCallback(e, s);
       if (replacement == null) {
         dart.dcall(onError, e, s);
       } else {
         let error = _nonNullError(replacement.error);
         let stackTrace = replacement.stackTrace;
         dart.dcall(onError, error, stackTrace);
       }
     }
 
   }
-  dart.fn(_runUserCode, core.Object, [dart.functionType(core.Object, []), dart.functionType(core.Object, [dart.bottom]), dart.functionType(core.Object, [dart.bottom, core.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();
     if (dart.is(cancelFuture, Future)) {
       cancelFuture.whenComplete(dart.fn(() => future[_completeError](error, stackTrace), dart.void, []));
     } else {
       future[_completeError](error, stackTrace);
     }
   }
-  dart.fn(_cancelAndError, dart.void, [StreamSubscription, _Future, core.Object, core.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);
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     _cancelAndError(subscription, future, error, stackTrace);
   }
-  dart.fn(_cancelAndErrorWithReplacement, dart.void, [StreamSubscription, _Future, core.Object, core.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, [core.Object, core.StackTrace]);
+    return dart.fn((error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace), dart.void, [dart.dynamic, core.StackTrace]);
   }
-  dart.fn(_cancelAndErrorClosure, core.Object, [StreamSubscription, _Future]);
+  dart.fn(_cancelAndErrorClosure, dart.dynamic, [StreamSubscription, _Future]);
   function _cancelAndValue(subscription, future, value) {
     let cancelFuture = subscription.cancel();
     if (dart.is(cancelFuture, Future)) {
       cancelFuture.whenComplete(dart.fn(() => future[_complete](value), dart.void, []));
     } else {
       future[_complete](value);
     }
   }
-  dart.fn(_cancelAndValue, dart.void, [StreamSubscription, _Future, core.Object]);
+  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() {
@@ skipping 27 matching lines @@
         dart.as(sink, _EventSink$(T));
         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, [core.Object, core.StackTrace, _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;
@@ skipping 39 matching lines @@
       }
       [_handleDone]() {
         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, [core.Object, core.StackTrace]],
+        [_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));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     sink[_addError](error, dart.as(stackTrace, core.StackTrace));
   }
-  dart.fn(_addErrorWithReplacement, dart.void, [_EventSink, core.Object, core.Object]);
+  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));
@@ skipping 73 matching lines @@
 
       }
     }
     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.bottom]));
+  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;
@@ skipping 19 matching lines @@
             }
             return;
           }
 
         } else {
           sink[_addError](error, stackTrace);
         }
       }
     }
     dart.setSignature(_HandleErrorStream, {
-      constructors: () => ({_HandleErrorStream: [_HandleErrorStream$(T), [Stream$(T), core.Function, dart.functionType(core.bool, [dart.bottom])]]}),
+      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;
@@ skipping 185 matching lines @@
       }
       close() {
         this[_sink][_close]();
       }
     }
     _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_EventSinkWrapper, {
       constructors: () => ({_EventSinkWrapper: [_EventSinkWrapper$(T), [_EventSink]]}),
       methods: () => ({
         add: [dart.void, [T]],
-        addError: [dart.void, [core.Object], [core.StackTrace]],
+        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) {
@@ skipping 77 matching lines @@
           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, [core.Object], [core.Object]],
+        [_handleError]: [dart.void, [dart.dynamic], [dart.dynamic]],
         [_handleDone]: [dart.void, []]
       })
     });
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
   let _SinkMapper$ = dart.generic(function(S, T) {
     let _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
     return _SinkMapper;
   });
@@ skipping 27 matching lines @@
         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);
-        let subscription = new (_SinkTransformerStreamSubscription$(core.Object, T))(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, 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;
   });
   let _BoundSinkStream = _BoundSinkStream$();
@@ skipping 53 matching lines @@
         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);
           if (handleError == null)
             handleError = dart.as(_StreamHandlerTransformer$()._defaultHandleError, __CastType30);
           if (handleDone == null)
             handleDone = _StreamHandlerTransformer$()._defaultHandleDone;
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
-        }, core.Object, [EventSink$(T)]), _SinkMapper$(S, T)));
+        }, dart.dynamic, [EventSink$(T)]), _SinkMapper$(S, T)));
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return super.bind(stream);
       }
       static _defaultHandleData(data, sink) {
         sink.add(data);
       }
       static _defaultHandleError(error, stackTrace, sink) {
         sink.addError(error);
       }
       static _defaultHandleDone(sink) {
         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, [core.Object, EventSink]],
-        _defaultHandleError: [dart.void, [core.Object, core.StackTrace, EventSink]],
+        _defaultHandleData: [dart.void, [dart.dynamic, EventSink]],
+        _defaultHandleError: [dart.void, [dart.dynamic, core.StackTrace, EventSink]],
         _defaultHandleDone: [dart.void, [EventSink]]
       }),
       names: ['_defaultHandleData', '_defaultHandleError', '_defaultHandleDone']
     });
     return _StreamHandlerTransformer;
   });
   let _StreamHandlerTransformer = _StreamHandlerTransformer$();
   let _SubscriptionTransformer$ = dart.generic(function(S, T) {
     let _SubscriptionTransformer = dart.typedef('_SubscriptionTransformer', () => dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool]));
     return _SubscriptionTransformer;
@@ skipping 91 matching lines @@
       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(core.Object, []));
-  let ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionType(core.Object, [dart.bottom]));
-  let ZoneBinaryCallback = dart.typedef('ZoneBinaryCallback', () => dart.functionType(core.Object, [dart.bottom, dart.bottom]));
-  let HandleUncaughtErrorHandler = dart.typedef('HandleUncaughtErrorHandler', () => dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.bottom, core.StackTrace]));
-  let RunHandler = dart.typedef('RunHandler', () => dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]));
-  let RunUnaryHandler = dart.typedef('RunUnaryHandler', () => dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom]), dart.bottom]));
-  let RunBinaryHandler = dart.typedef('RunBinaryHandler', () => dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), dart.bottom, dart.bottom]));
-  let RegisterCallbackHandler = dart.typedef('RegisterCallbackHandler', () => dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]));
-  let RegisterUnaryCallbackHandler = dart.typedef('RegisterUnaryCallbackHandler', () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom])]));
-  let RegisterBinaryCallbackHandler = dart.typedef('RegisterBinaryCallbackHandler', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom])]));
+  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])]));
   let ErrorCallbackHandler = dart.typedef('ErrorCallbackHandler', () => dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]));
-  let ScheduleMicrotaskHandler = dart.typedef('ScheduleMicrotaskHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]));
+  let ScheduleMicrotaskHandler = dart.typedef('ScheduleMicrotaskHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
   let CreateTimerHandler = dart.typedef('CreateTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]));
   let CreatePeriodicTimerHandler = dart.typedef('CreatePeriodicTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]));
   let PrintHandler = dart.typedef('PrintHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]));
   let ForkHandler = dart.typedef('ForkHandler', () => dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]));
   class _ZoneFunction extends core.Object {
     _ZoneFunction(zone, func) {
       this.zone = zone;
       this.function = func;
     }
   }
@@ skipping 16 matching lines @@
       let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
       let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
       let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.createPeriodicTimer : null;
       let print = opts && 'print' in opts ? opts.print : null;
       let fork = opts && 'fork' in opts ? opts.fork : null;
       return ZoneSpecification.new({handleUncaughtError: handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, run: run != null ? run : other.run, runUnary: runUnary != null ? runUnary : other.runUnary, runBinary: runBinary != null ? runBinary : other.runBinary, registerCallback: registerCallback != null ? registerCallback : other.registerCallback, registerUnaryCallback: registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, registerBinaryCallback: registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, errorCallback: errorCallback != null ? errorCallback : other.errorCallback, scheduleMicrotask: scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, createTimer: createTimer != null ? createTimer : other.createTimer, createPeriodicTimer: createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, print: print != null ? print : other.print, fork: fork != null ? fork : other.fork});
     }
   }
   dart.setSignature(ZoneSpecification, {
     constructors: () => ({
-      new: [ZoneSpecification, [], {handleUncaughtError: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.bottom, core.StackTrace]), run: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), runUnary: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom]), dart.bottom]), runBinary: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), dart.bottom, dart.bottom]), registerCallback: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom])]), registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom])]), errorCallback: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), scheduleMicrotask: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), createTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]), createPeriodicTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), print: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), fork: dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}],
-      from: [ZoneSpecification, [ZoneSpecification], {handleUncaughtError: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.bottom, core.StackTrace]), run: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), runUnary: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom]), dart.bottom]), runBinary: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), dart.bottom, dart.bottom]), registerCallback: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom])]), registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom])]), errorCallback: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), scheduleMicrotask: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), createTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]), createPeriodicTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), print: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), fork: dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}]
+      new: [ZoneSpecification, [], {handleUncaughtError: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]), run: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), runUnary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]), runBinary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]), registerCallback: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]), registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]), errorCallback: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), scheduleMicrotask: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), createTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]), createPeriodicTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), print: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), fork: dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}],
+      from: [ZoneSpecification, [ZoneSpecification], {handleUncaughtError: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]), run: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), runUnary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]), runBinary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]), registerCallback: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]), registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]), errorCallback: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), scheduleMicrotask: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), createTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]), createPeriodicTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), print: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), fork: dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}]
     })
   });
   class _ZoneSpecification extends core.Object {
     _ZoneSpecification(opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
@@ skipping 242 matching lines @@
     createPeriodicTimer(duration, f) {
       return Timer._createPeriodicTimer(duration, f);
     }
     print(line) {
       _internal.printToConsole(line);
     }
   }
   dart.setSignature(_RootZone, {
     constructors: () => ({_RootZone: [_RootZone, []]}),
     methods: () => ({
-      runGuarded: [core.Object, [dart.functionType(core.Object, [])]],
-      runUnaryGuarded: [core.Object, [dart.functionType(core.Object, [dart.bottom]), core.Object]],
-      runBinaryGuarded: [core.Object, [dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]],
-      bindCallback: [ZoneCallback, [dart.functionType(core.Object, [])], {runGuarded: core.bool}],
-      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(core.Object, [dart.bottom])], {runGuarded: core.bool}],
-      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(core.Object, [dart.bottom, dart.bottom])], {runGuarded: core.bool}],
-      get: [core.Object, [core.Object]],
-      handleUncaughtError: [core.Object, [core.Object, core.StackTrace]],
+      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: [core.Object, [dart.functionType(core.Object, [])]],
-      runUnary: [core.Object, [dart.functionType(core.Object, [dart.bottom]), core.Object]],
-      runBinary: [core.Object, [dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]],
-      registerCallback: [ZoneCallback, [dart.functionType(core.Object, [])]],
-      registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(core.Object, [dart.bottom])]],
-      registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(core.Object, [dart.bottom, dart.bottom])]],
+      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;
@@ skipping 73 matching lines @@
     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);
     }
   }
   _ZoneDelegate[dart.implements] = () => [ZoneDelegate];
   dart.setSignature(_ZoneDelegate, {
     constructors: () => ({_ZoneDelegate: [_ZoneDelegate, [_Zone]]}),
     methods: () => ({
-      handleUncaughtError: [core.Object, [Zone, core.Object, core.StackTrace]],
-      run: [core.Object, [Zone, dart.functionType(core.Object, [])]],
-      runUnary: [core.Object, [Zone, dart.functionType(core.Object, [dart.bottom]), core.Object]],
-      runBinary: [core.Object, [Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]],
-      registerCallback: [ZoneCallback, [Zone, dart.functionType(core.Object, [])]],
-      registerUnaryCallback: [ZoneUnaryCallback, [Zone, dart.functionType(core.Object, [dart.bottom])]],
-      registerBinaryCallback: [ZoneBinaryCallback, [Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom])]],
+      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]],
+      registerCallback: [ZoneCallback, [Zone, dart.functionType(dart.dynamic, [])]],
+      registerUnaryCallback: [ZoneUnaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic])]],
+      registerBinaryCallback: [ZoneBinaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
       errorCallback: [AsyncError, [Zone, core.Object, core.StackTrace]],
-      scheduleMicrotask: [dart.void, [Zone, dart.functionType(core.Object, [])]],
+      scheduleMicrotask: [dart.void, [Zone, dart.functionType(dart.dynamic, [])]],
       createTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [])]],
       createPeriodicTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [Timer])]],
       print: [dart.void, [Zone, core.String]],
       fork: [Zone, [Zone, ZoneSpecification, core.Map]]
     })
   });
   let _delegateCache = Symbol('_delegateCache');
   class _CustomZone extends _Zone {
     get [_delegate]() {
       if (this[_delegateCache] != null)
@@ skipping 184 matching lines @@
     print(line) {
       let implementation = this[_print];
       dart.assert(implementation != null);
       let parentDelegate = _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: [core.Object, [dart.functionType(core.Object, [])]],
-      runUnaryGuarded: [core.Object, [dart.functionType(core.Object, [dart.bottom]), core.Object]],
-      runBinaryGuarded: [core.Object, [dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]],
-      bindCallback: [ZoneCallback, [dart.functionType(core.Object, [])], {runGuarded: core.bool}],
-      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(core.Object, [dart.bottom])], {runGuarded: core.bool}],
-      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(core.Object, [dart.bottom, dart.bottom])], {runGuarded: core.bool}],
-      get: [core.Object, [core.Object]],
-      handleUncaughtError: [core.Object, [core.Object, core.StackTrace]],
+      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: [core.Object, [dart.functionType(core.Object, [])]],
-      runUnary: [core.Object, [dart.functionType(core.Object, [dart.bottom]), core.Object]],
-      runBinary: [core.Object, [dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]],
-      registerCallback: [ZoneCallback, [dart.functionType(core.Object, [])]],
-      registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(core.Object, [dart.bottom])]],
-      registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(core.Object, [dart.bottom, dart.bottom])]],
+      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(() => {
       throw new _UncaughtAsyncError(error, stackTrace);
     }));
   }
-  dart.fn(_rootHandleUncaughtError, dart.void, [Zone, ZoneDelegate, Zone, core.Object, core.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);
     try {
       return f();
     } finally {
       Zone._leave(old);
     }
   }
-  dart.fn(_rootRun, core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]);
+  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);
     try {
       return dart.dcall(f, arg);
     } finally {
       Zone._leave(old);
     }
   }
-  dart.fn(_rootRunUnary, core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom]), core.Object]);
+  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);
     try {
       return dart.dcall(f, arg1, arg2);
     } finally {
       Zone._leave(old);
     }
   }
-  dart.fn(_rootRunBinary, core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]);
+  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(core.Object, [])]);
+  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(core.Object, [dart.bottom])]);
+  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(core.Object, [dart.bottom, dart.bottom])]);
+  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});
     }
     _scheduleAsyncCallback(f);
   }
-  dart.fn(_rootScheduleMicrotask, dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]);
+  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);
     }
     return 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);
@@ skipping 92 matching lines @@
           return self.parent.runUnary(dart.as(onError, __CastType38), error);
         } catch (e) {
           let s = dart.stackTrace(e);
           if (dart.notNull(core.identical(e, error))) {
             return parent.handleUncaughtError(zone, error, stackTrace);
           } else {
             return parent.handleUncaughtError(zone, e, s);
           }
         }
 
-      }, core.Object, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]);
+      }, 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});
     if (onError != null) {
       return zone.runGuarded(body);
     } else {
       return zone.run(body);
     }
   }
-  dart.fn(runZoned, core.Object, [dart.functionType(core.Object, [])], {zoneValues: core.Map, zoneSpecification: ZoneSpecification, onError: core.Function});
+  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(core.Object, [dart.bottom]));
+  let __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   dart.copyProperties(exports, {
     get _hasDocument() {
       return typeof document == 'object';
     }
   });
   // Exports:
   exports.AsyncError = AsyncError;
   exports.Stream$ = Stream$;
   exports.Stream = Stream;
   exports.DeferredLibrary = DeferredLibrary;
@@ skipping 35 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;
 });