No dynamic at runtime

lib/runtime/dart/async.js

 var async = dart.defineLibrary(async, {});
 var core = dart.import(core);
 var _internal = dart.import(_internal);
 var _js_helper = dart.lazyImport(_js_helper);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 var collection = dart.import(collection);
 (function(exports, core, _internal, _js_helper, _isolate_helper, collection) {
   'use strict';
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dcall(errorHandler, error, stackTrace);
     } else {
       return dart.dcall(errorHandler, error);
     }
   }
-  dart.fn(_invokeErrorHandler, dart.dynamic, [core.Function, core.Object, core.StackTrace]);
+  dart.fn(_invokeErrorHandler, core.Object, [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]));
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
@@ skipping 19 matching lines @@
     }
     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, {
-    statics: () => ({_getBestStackTrace: [core.StackTrace, [dart.dynamic, core.StackTrace]]}),
+    statics: () => ({_getBestStackTrace: [core.StackTrace, [core.Object, core.StackTrace]]}),
     names: ['_getBestStackTrace']
   });
-  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [dart.bottom]));
   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() {
       }
       fromFuture(future) {
         let controller = dart.as(new (StreamController$(T))({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;
       }
       fromIterable(data) {
         return new (_GeneratedStreamImpl$(T))(dart.fn(() => new (_IterablePendingEvents$(T))(data), _IterablePendingEvents$(T), []));
       }
       periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation == null)
-          computation = dart.fn(i => null, dart.bottom, [dart.dynamic]);
+          computation = dart.fn(i => null, dart.bottom, [core.Object]);
         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 = new Timer.periodic(period, dart.fn(timer => {
             sendEvent();
-          }, dart.dynamic, [Timer]));
+          }, core.Object, [Timer]));
         };
         dart.fn(startPeriodicTimer, dart.void, []);
         controller = new (StreamController$(T))({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 = new Timer(period['-'](elapsed), dart.fn(() => {
               timer = null;
               startPeriodicTimer();
               sendEvent();
             }));
           }), onCancel: dart.fn(() => {
             if (timer != null)
               timer.cancel();
             timer = null;
           })});
         return controller.stream;
       }
       eventTransformed(source, mapSink) {
-        return new (_BoundSinkStream$(dart.dynamic, T))(source, dart.as(mapSink, _SinkMapper));
+        return new (_BoundSinkStream$(core.Object, 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(dart.dynamic, [T]));
-        return new (_MapStream$(T, dart.dynamic))(this, convert);
+        dart.as(convert, dart.functionType(core.Object, [T]));
+        return new (_MapStream$(T, core.Object))(this, convert);
       }
       asyncMap(convert) {
-        dart.as(convert, dart.functionType(dart.dynamic, [T]));
+        dart.as(convert, dart.functionType(core.Object, [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);
             }
-          }, dart.dynamic, [T]), {onError: dart.as(addError, core.Function), onDone: dart.bind(controller, 'close')});
+          }, core.Object, [T]), {onError: dart.as(addError, core.Function), onDone: dart.bind(controller, 'close')});
         }).bind(this);
         dart.fn(onListen, dart.void, []);
         if (this.isBroadcast) {
           controller = new StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
             }), sync: true});
         } else {
           controller = new StreamController({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'));
             }
-          }, dart.dynamic, [T]), {onError: dart.as(eventSink[_addError], core.Function), onDone: dart.bind(controller, 'close')});
+          }, core.Object, [T]), {onError: dart.as(eventSink[_addError], core.Function), onDone: dart.bind(controller, 'close')});
         }).bind(this);
         dart.fn(onListen, dart.void, []);
         if (this.isBroadcast) {
           controller = new StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
             }), sync: true});
         } else {
           controller = new StreamController({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.dynamic]));
+        dart.as(test, dart.functionType(core.bool, [dart.bottom]));
         return new (_HandleErrorStream$(T))(this, onError, test);
       }
       expand(convert) {
         dart.as(convert, dart.functionType(core.Iterable, [T]));
-        return new (_ExpandStream$(T, dart.dynamic))(this, convert);
+        return new (_ExpandStream$(T, core.Object))(this, convert);
       }
       pipe(streamConsumer) {
         dart.as(streamConsumer, StreamConsumer$(T));
-        return streamConsumer.addStream(this).then(dart.fn(_ => streamConsumer.close(), Future, [dart.dynamic]));
+        return streamConsumer.addStream(this).then(dart.fn(_ => streamConsumer.close(), Future, [core.Object]));
       }
       transform(streamTransformer) {
-        dart.as(streamTransformer, StreamTransformer$(T, dart.dynamic));
+        dart.as(streamTransformer, StreamTransformer$(T, core.Object));
         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 (seenFirst) {
             _runUserCode(dart.fn(() => combine(value, element), T, []), dart.fn(newValue => {
               dart.as(newValue, T);
               value = newValue;
-            }, dart.dynamic, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
+            }, core.Object, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
           } else {
             value = element;
             seenFirst = true;
           }
-        }, dart.dynamic, [T]), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
+        }, core.Object, [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(dart.dynamic, [dart.dynamic, T]));
+        dart.as(combine, dart.functionType(core.Object, [dart.bottom, 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(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.fn((e, st) => {
+          }), dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
+        }, core.Object, [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);
           }
 
-        }, dart.dynamic, [T]), {onError: dart.fn(e => {
+        }, core.Object, [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 (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
-          }, 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(() => {
+          }, 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(() => {
             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(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: 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(() => {
             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);
             }
-          }, 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(() => {
+          }, 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(() => {
             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 (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
-          }, 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(() => {
+          }, 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(() => {
             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.setType([], core.List$(T));
         let future = new (_Future$(core.List$(T)))();
         this.listen(dart.fn(data => {
           dart.as(data, T);
           result[core.$add](data);
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](result);
           }), cancelOnError: true});
         return future;
       }
       toSet() {
         let result = new (core.Set$(T))();
         let future = new (_Future$(core.Set$(T)))();
         this.listen(dart.fn(data => {
           dart.as(data, T);
           result.add(data);
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, core.Object, [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);
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, core.Object, [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;
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (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;
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (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 (isMatch) {
               _cancelAndValue(subscription, future, value);
             }
-          }, 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(() => {
+          }, 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(() => {
             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 (isMatch) {
               foundResult = true;
               result = value;
             }
-          }, 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(() => {
+          }, 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(() => {
             if (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;
             }
-          }, 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(() => {
+          }, 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(() => {
             if (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;
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn((() => {
+        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn((() => {
             future[_completeError](new core.RangeError.index(index, this, "index", null, elementIndex));
           }).bind(this)), cancelOnError: true});
         return future;
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         dart.as(onTimeout, dart.functionType(dart.void, [EventSink]));
         let controller = null;
         let subscription = null;
         let timer = null;
         let zone = null;
         let timeout = null;
         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, [dart.dynamic, core.StackTrace]);
+        dart.fn(onError, dart.void, [core.Object, 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 29 matching lines @@
       }
     }
     dart.defineNamedConstructor(Stream, 'fromFuture');
     dart.defineNamedConstructor(Stream, 'fromIterable');
     dart.defineNamedConstructor(Stream, 'periodic');
     dart.defineNamedConstructor(Stream, 'eventTransformed');
     dart.setSignature(Stream, {
       methods: () => ({
         asBroadcastStream: [Stream$(T), [], {nListe: dart.functionType(dart.void, [StreamSubscription$(T)]), nCance: dart.functionType(dart.void, [StreamSubscription$(T)])}],
         where: [Stream$(T), [dart.functionType(core.bool, [T])]],
-        map: [Stream$(), [dart.functionType(dart.dynamic, [T])]],
-        asyncMap: [Stream$(), [dart.functionType(dart.dynamic, [T])]],
+        map: [Stream$(), [dart.functionType(core.Object, [T])]],
+        asyncMap: [Stream$(), [dart.functionType(core.Object, [T])]],
         asyncExpand: [Stream$(), [dart.functionType(Stream$(), [T])]],
-        handleError: [Stream$(T), [core.Function], {es: dart.functionType(core.bool, [dart.dynamic])}],
+        handleError: [Stream$(T), [core.Function], {es: dart.functionType(core.bool, [dart.bottom])}],
         expand: [Stream$(), [dart.functionType(core.Iterable, [T])]],
         pipe: [Future, [StreamConsumer$(T)]],
-        transform: [Stream$(), [StreamTransformer$(T, dart.dynamic)]],
+        transform: [Stream$(), [StreamTransformer$(T, core.Object)]],
         reduce: [Future$(T), [dart.functionType(T, [T, T])]],
-        fold: [Future, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, T])]],
+        fold: [Future, [core.Object, dart.functionType(core.Object, [dart.bottom, 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, [], [dart.dynamic]],
+        drain: [Future, [], [core.Object]],
         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])], {efaultValu: dart.functionType(core.Object, [])}],
         lastWhere: [Future, [dart.functionType(core.bool, [T])], {efaultValu: dart.functionType(core.Object, [])}],
         singleWhere: [Future$(T), [dart.functionType(core.bool, [T])]],
         elementAt: [Future$(T), [core.int]],
         timeout: [Stream$(), [core.Duration], {nTimeou: dart.functionType(dart.void, [EventSink])}]
@@ skipping 426 matching lines @@
     dart.setSignature(_BufferingStreamSubscription, {
       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, [], [dart.dynamic]],
+        asFuture: [Future, [], [core.Object]],
         [_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, [dart.dynamic]],
+        [_guardCallback]: [dart.void, [core.Object]],
         [_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 331 matching lines @@
           subscription[_add](data);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
           if (this[_isEmpty]) {
             this[_callOnCancel]();
           }
           return;
         }
         this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_add](data);
-        }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
+        }, core.Object, [_BufferingStreamSubscription$(T)]));
       }
       [_sendError](error, stackTrace) {
         if (this[_isEmpty])
           return;
         this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_addError](error, stackTrace);
-        }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
+        }, core.Object, [_BufferingStreamSubscription$(T)]));
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
           this[_forEachListener](dart.as(dart.fn(subscription => {
             dart.as(subscription, _BroadcastSubscription$(T));
             subscription[_close]();
-          }, dart.dynamic, [_BroadcastSubscription$(T)]), __CastType2));
+          }, core.Object, [_BroadcastSubscription$(T)]), __CastType2));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     dart.setSignature(_SyncBroadcastStreamController, {
       methods: () => ({
         [_sendData]: [dart.void, [T]],
@@ skipping 156 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, [dart.dynamic]],
+        [_resume]: [dart.void, [core.Object]],
         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 90 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.dynamic]));
+        dart.as(cleanUp, dart.functionType(dart.void, [dart.bottom]));
         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) {
                   new (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, [dart.dynamic, dart.dynamic]);
+        dart.fn(handleError, dart.void, [core.Object, core.Object]);
         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[core.$set](pos, value);
               if (remaining == 0) {
                 result[_completeWithValue](values);
               }
             } else {
               if (dart.notNull(cleanUp != null) && dart.notNull(value != null)) {
                 new (Future$()).sync(dart.fn(() => {
                   dart.dcall(cleanUp, value);
                 }));
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result[_completeError](error, stackTrace);
               }
             }
-          }, dart.dynamic, [core.Object]), {onError: handleError});
+          }, core.Object, [core.Object]), {onError: handleError});
         }
         if (remaining == 0) {
           return new (Future$(core.List)).value(dart.const([]));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
-        dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
+        dart.as(f, dart.functionType(core.Object, [dart.bottom]));
         let iterator = input[core.$iterator];
         return Future$().doWhile(dart.fn(() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
-          return new (Future$()).sync(dart.fn(() => dart.dcall(f, iterator.current))).then(dart.fn(_ => true, core.bool, [dart.dynamic]));
+          return new (Future$()).sync(dart.fn(() => dart.dcall(f, iterator.current))).then(dart.fn(_ => true, core.bool, [core.Object]));
         }));
       }
       static doWhile(f) {
-        dart.as(f, dart.functionType(dart.dynamic, []));
+        dart.as(f, dart.functionType(core.Object, []));
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback(dart.fn(keepGoing => {
           if (keepGoing) {
             new (Future$()).sync(f).then(dart.as(nextIteration, __CastType4), {onError: dart.bind(doneSignal, _completeError)});
           } else {
             doneSignal[_complete](null);
           }
-        }, dart.dynamic, [core.bool]), {runGuarded: true});
+        }, core.Object, [core.bool]), {runGuarded: true});
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
     dart.setSignature(Future, {
       statics: () => ({
-        wait: [Future$(core.List), [core.Iterable$(Future$())], {agerErro: core.bool, leanU: dart.functionType(dart.void, [dart.dynamic])}],
-        forEach: [Future$(), [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic])]],
-        doWhile: [Future$(), [dart.functionType(dart.dynamic, [])]]
+        wait: [Future$(core.List), [core.Iterable$(Future$())], {agerErro: core.bool, leanU: dart.functionType(dart.void, [dart.bottom])}],
+        forEach: [Future$(), [core.Iterable, dart.functionType(core.Object, [dart.bottom])]],
+        doWhile: [Future$(), [dart.functionType(core.Object, [])]]
       }),
       names: ['wait', 'forEach', 'doWhile']
     });
     return Future;
   });
   let Future = Future$();
   dart.defineLazyProperties(Future, {
     get _nullFuture() {
       return new _Future.immediate(null);
     }
@@ skipping 29 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, dart.dynamic, dart.dynamic]));
+  dart.fn(_completeWithErrorCallback, () => dart.functionType(dart.void, [_Future, core.Object, core.Object]));
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
   dart.fn(_nonNullError, core.Object, [core.Object]);
-  let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(core.Object, [dart.bottom]));
   let _FutureOnValue$ = dart.generic(function(T) {
-    let _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType(dart.dynamic, [T]));
+    let _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType(core.Object, [T]));
     return _FutureOnValue;
   });
   let _FutureOnValue = _FutureOnValue$();
-  let _FutureErrorTest = dart.typedef('_FutureErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
-  let _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(dart.dynamic, []));
+  let _FutureErrorTest = dart.typedef('_FutureErrorTest', () => dart.functionType(core.bool, [dart.bottom]));
+  let _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(core.Object, []));
   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, [], [dart.dynamic]],
+        complete: [dart.void, [], [core.Object]],
         [_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, [], [dart.dynamic]],
+        complete: [dart.void, [], [core.Object]],
         [_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 122 matching lines @@
       set [_isChained](value) {
         if (value) {
           dart.assert(!dart.notNull(this[_isComplete]));
           this[_state] = _Future$()._CHAINED;
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future$()._INCOMPLETE;
         }
       }
       then(f, opts) {
-        dart.as(f, dart.functionType(dart.dynamic, [T]));
+        dart.as(f, dart.functionType(core.Object, [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.dynamic]));
+        dart.as(test, dart.functionType(core.bool, [dart.bottom]));
         let result = new (_Future$())();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           onError = _registerErrorHandler(onError, result[_zone]);
           if (test != null)
             test = dart.as(result[_zone].registerUnaryCallback(test), __CastType8);
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
-        dart.as(action, dart.functionType(dart.dynamic, []));
+        dart.as(action, dart.functionType(core.Object, []));
         let result = new (_Future$(T))();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           action = result[_zone].registerCallback(action);
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
         return dart.as(result, Future$(T));
       }
       asStream() {
         return new (Stream$(T)).fromFuture(this);
       }
@@ 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));
-          }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
+          }, core.Object, [core.Object], [core.Object])});
       }
       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 (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));
-                  }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
+                  }, core.Object, [core.Object], [core.Object])});
               }
             };
             dart.fn(handleWhenCompleteCallback, dart.void, []);
             if (!dart.notNull(hasError)) {
               if (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(dart.dynamic, []));
+        dart.as(onTimeout, dart.functionType(core.Object, []));
         if (this[_isComplete])
           return new (_Future$()).immediate(this);
         let result = new (_Future$())();
         let timer = null;
         if (onTimeout == null) {
           timer = new Timer(timeLimit, dart.fn(() => {
             result[_completeError](new TimeoutException("Future not completed", timeLimit));
           }));
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
           timer = new Timer(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 (timer.isActive) {
             timer.cancel();
             result[_completeWithValue](v);
           }
-        }, dart.dynamic, [T]), {onError: dart.fn((e, s) => {
+        }, core.Object, [T]), {onError: dart.fn((e, s) => {
             if (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, {
       methods: () => ({
-        then: [Future, [dart.functionType(dart.dynamic, [T])], {nErro: core.Function}],
-        catchError: [Future, [core.Function], {es: dart.functionType(core.bool, [dart.dynamic])}],
-        whenComplete: [Future$(T), [dart.functionType(dart.dynamic, [])]],
+        then: [Future, [dart.functionType(core.Object, [T])], {nErro: core.Function}],
+        catchError: [Future, [core.Function], {es: dart.functionType(core.bool, [dart.bottom])}],
+        whenComplete: [Future$(T), [dart.functionType(core.Object, [])]],
         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, [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], {nTimeou: dart.functionType(dart.dynamic, [])}]
+        [_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], {nTimeou: dart.functionType(core.Object, [])}]
       }),
       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(dart.dynamic, [T]));
+    let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(core.Object, [T]));
     return __CastType6;
   });
   let __CastType6 = __CastType6$();
-  let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.dynamic]));
-  let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.bottom]));
+  let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(core.Object, [dart.bottom]));
   let _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(dart.void, []));
   class _AsyncCallbackEntry extends core.Object {
     _AsyncCallbackEntry(callback) {
       this.callback = callback;
       this.next = null;
     }
   }
   exports._nextCallback = null;
   exports._lastCallback = null;
   exports._lastPriorityCallback = null;
@@ skipping 26 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, [dart.dynamic]);
+  dart.fn(_scheduleAsyncCallback, dart.void, [core.Object]);
   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, [dart.dynamic]);
+  dart.fn(_schedulePriorityAsyncCallback, dart.void, [core.Object]);
   function scheduleMicrotask(callback) {
     if (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 16 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);
-        }, dart.dynamic, [dart.functionType(dart.void, [])]);
+        }, core.Object, [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 125 matching lines @@
         this[_sink].addError(error, stackTrace);
       }
       close() {
         this[_sink].close();
       }
     }
     _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_ControllerEventSinkWrapper, {
       methods: () => ({
         add: [dart.void, [T]],
-        addError: [dart.void, [dart.dynamic], [core.StackTrace]],
+        addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _ControllerEventSinkWrapper;
   });
   let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
   let __CastType12 = dart.typedef('__CastType12', () => dart.functionType(dart.void, [StreamSubscription]));
-  let __CastType14 = dart.typedef('__CastType14', () => dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace]));
+  let __CastType14 = dart.typedef('__CastType14', () => dart.functionType(core.Object, [dart.bottom, 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 {
       StreamController(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;
@@ skipping 378 matching lines @@
     }
     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(dart.dynamic, []));
+  let _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(core.Object, []));
   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 44 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: 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]();
-        }, dart.dynamic, [dart.dynamic, core.StackTrace]);
+        }, core.Object, [core.Object, 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);
         }).bind(this)));
       }
       complete() {
         this.addStreamFuture[_asyncComplete](null);
       }
     }
     dart.setSignature(_AddStreamState, {
       methods: () => ({
         pause: [dart.void, []],
         resume: [dart.void, []],
         cancel: [Future, []],
         complete: [dart.void, []]
       }),
-      statics: () => ({makeErrorHandler: [dart.dynamic, [_EventSink]]}),
+      statics: () => ({makeErrorHandler: [core.Object, [_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);
@@ skipping 138 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, [dart.dynamic]);
+  dart.fn(_nullDataHandler, dart.void, [core.Object]);
   function _nullErrorHandler(error, stackTrace) {
     if (stackTrace === void 0)
       stackTrace = null;
     Zone.current.handleUncaughtError(error, stackTrace);
   }
-  dart.fn(_nullErrorHandler, dart.void, [dart.dynamic], [core.StackTrace]);
+  dart.fn(_nullErrorHandler, dart.void, [core.Object], [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 187 matching lines @@
     _DoneStreamSubscription[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_DoneStreamSubscription, {
       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, [], [dart.dynamic]],
+        asFuture: [Future, [], [core.Object]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _DoneStreamSubscription;
   });
   let _DoneStreamSubscription = _DoneStreamSubscription$();
   _DoneStreamSubscription._DONE_SENT = 1;
   _DoneStreamSubscription._SCHEDULED = 2;
   _DoneStreamSubscription._PAUSED = 4;
   let _source = Symbol('_source');
@@ skipping 126 matching lines @@
     }
     _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_BroadcastSubscriptionWrapper, {
       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, [], [dart.dynamic]]
+        asFuture: [Future, [], [core.Object]]
       })
     });
     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 120 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(dart.dynamic, [dart.dynamic, dart.dynamic]));
-  let __CastType25 = dart.typedef('__CastType25', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType22 = dart.typedef('__CastType22', () => dart.functionType(core.Object, [dart.bottom, dart.bottom]));
+  let __CastType25 = dart.typedef('__CastType25', () => dart.functionType(core.Object, [dart.bottom]));
   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, dart.dynamic, [dart.functionType(dart.dynamic, []), dart.functionType(dart.dynamic, [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])]);
+  dart.fn(_runUserCode, core.Object, [dart.functionType(core.Object, []), dart.functionType(core.Object, [dart.bottom]), dart.functionType(core.Object, [dart.bottom, 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, dart.dynamic, core.StackTrace]);
+  dart.fn(_cancelAndError, dart.void, [StreamSubscription, _Future, core.Object, 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, dart.dynamic, core.StackTrace]);
+  dart.fn(_cancelAndErrorWithReplacement, dart.void, [StreamSubscription, _Future, core.Object, core.StackTrace]);
   function _cancelAndErrorClosure(subscription, future) {
-    return dart.fn((error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace), dart.void, [dart.dynamic, core.StackTrace]);
+    return dart.fn((error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace), dart.void, [core.Object, core.StackTrace]);
   }
-  dart.fn(_cancelAndErrorClosure, dart.dynamic, [StreamSubscription, _Future]);
+  dart.fn(_cancelAndErrorClosure, core.Object, [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, dart.dynamic]);
+  dart.fn(_cancelAndValue, dart.void, [StreamSubscription, _Future, core.Object]);
   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 26 matching lines @@
       [_handleDone](sink) {
         dart.as(sink, _EventSink$(T));
         sink[_close]();
       }
     }
     dart.setSignature(_ForwardingStream, {
       methods: () => ({
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}],
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_handleData]: [dart.void, [S, _EventSink$(T)]],
-        [_handleError]: [dart.void, [dart.dynamic, core.StackTrace, _EventSink$(T)]],
+        [_handleError]: [dart.void, [core.Object, 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 38 matching lines @@
         this[_stream][_handleError](error, stackTrace, this);
       }
       [_handleDone]() {
         this[_stream][_handleDone](this);
       }
     }
     dart.setSignature(_ForwardingStreamSubscription, {
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
-        [_handleError]: [dart.void, [dart.dynamic, core.StackTrace]],
+        [_handleError]: [dart.void, [core.Object, 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, dart.dynamic, dart.dynamic]);
+  dart.fn(_addErrorWithReplacement, dart.void, [_EventSink, core.Object, core.Object]);
   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 70 matching lines @@
         }
 
       }
     }
     dart.setSignature(_ExpandStream, {
       methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _ExpandStream;
   });
   let _ExpandStream = _ExpandStream$();
-  let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
+  let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.bottom]));
   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 218 matching lines @@
         this[_sink][_addError](error, stackTrace);
       }
       close() {
         this[_sink][_close]();
       }
     }
     _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_EventSinkWrapper, {
       methods: () => ({
         add: [dart.void, [T]],
-        addError: [dart.void, [dart.dynamic], [core.StackTrace]],
+        addError: [dart.void, [core.Object], [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 76 matching lines @@
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
     }
     dart.setSignature(_SinkTransformerStreamSubscription, {
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
-        [_handleError]: [dart.void, [dart.dynamic], [dart.dynamic]],
+        [_handleError]: [dart.void, [core.Object], [core.Object]],
         [_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 26 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$(dart.dynamic, T))(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
+        let subscription = new (_SinkTransformerStreamSubscription$(core.Object, T))(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     dart.setSignature(_BoundSinkStream, {
       methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}]})
     });
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$();
   let _TransformDataHandler$ = dart.generic(function(S, T) {
@@ skipping 51 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);
-        }, dart.dynamic, [EventSink$(T)]), _SinkMapper$(S, T)));
+        }, core.Object, [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, {
       methods: () => ({bind: [Stream$(T), [Stream$(S)]]}),
       statics: () => ({
-        _defaultHandleData: [dart.void, [dart.dynamic, EventSink]],
-        _defaultHandleError: [dart.void, [dart.dynamic, core.StackTrace, EventSink]],
+        _defaultHandleData: [dart.void, [core.Object, EventSink]],
+        _defaultHandleError: [dart.void, [core.Object, 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 86 matching lines @@
   dart.defineNamedConstructor(Timer, 'periodic');
   dart.setSignature(Timer, {
     statics: () => ({
       run: [dart.void, [dart.functionType(dart.void, [])]],
       _createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       _createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
     }),
     names: ['run', '_createTimer', '_createPeriodicTimer']
   });
   let __CastType34 = dart.typedef('__CastType34', () => dart.functionType(dart.void, [Timer]));
-  let ZoneCallback = dart.typedef('ZoneCallback', () => dart.functionType(dart.dynamic, []));
-  let ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  let ZoneBinaryCallback = dart.typedef('ZoneBinaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
-  let HandleUncaughtErrorHandler = dart.typedef('HandleUncaughtErrorHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]));
-  let RunHandler = dart.typedef('RunHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
-  let RunUnaryHandler = dart.typedef('RunUnaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]));
-  let RunBinaryHandler = dart.typedef('RunBinaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]));
-  let RegisterCallbackHandler = dart.typedef('RegisterCallbackHandler', () => dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
-  let RegisterUnaryCallbackHandler = dart.typedef('RegisterUnaryCallbackHandler', () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]));
-  let RegisterBinaryCallbackHandler = dart.typedef('RegisterBinaryCallbackHandler', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]));
+  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 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(dart.dynamic, [])]));
+  let ScheduleMicrotaskHandler = dart.typedef('ScheduleMicrotaskHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]));
   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 266 matching lines @@
     }
     createPeriodicTimer(duration, f) {
       return Timer._createPeriodicTimer(duration, f);
     }
     print(line) {
       _internal.printToConsole(line);
     }
   }
   dart.setSignature(_RootZone, {
     methods: () => ({
-      runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
-      runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
-      runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
-      bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {unGuarde: core.bool}],
-      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {unGuarde: core.bool}],
-      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {unGuarde: core.bool}],
-      get: [dart.dynamic, [core.Object]],
-      handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
+      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, [])], {unGuarde: core.bool}],
+      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(core.Object, [dart.bottom])], {unGuarde: core.bool}],
+      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(core.Object, [dart.bottom, dart.bottom])], {unGuarde: core.bool}],
+      get: [core.Object, [core.Object]],
+      handleUncaughtError: [core.Object, [core.Object, core.StackTrace]],
       fork: [Zone, [], {pecificatio: ZoneSpecification, oneValue: core.Map}],
-      run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
-      runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
-      runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
-      registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
-      registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
-      registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
+      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])]],
       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 72 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, {
     methods: () => ({
-      handleUncaughtError: [dart.dynamic, [Zone, dart.dynamic, core.StackTrace]],
-      run: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [])]],
-      runUnary: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
-      runBinary: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
-      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])]],
+      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])]],
       errorCallback: [AsyncError, [Zone, core.Object, core.StackTrace]],
-      scheduleMicrotask: [dart.void, [Zone, dart.functionType(dart.dynamic, [])]],
+      scheduleMicrotask: [dart.void, [Zone, dart.functionType(core.Object, [])]],
       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 183 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, {
     methods: () => ({
-      runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
-      runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
-      runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
-      bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {unGuarde: core.bool}],
-      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {unGuarde: core.bool}],
-      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {unGuarde: core.bool}],
-      get: [dart.dynamic, [core.Object]],
-      handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
+      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, [])], {unGuarde: core.bool}],
+      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(core.Object, [dart.bottom])], {unGuarde: core.bool}],
+      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(core.Object, [dart.bottom, dart.bottom])], {unGuarde: core.bool}],
+      get: [core.Object, [core.Object]],
+      handleUncaughtError: [core.Object, [core.Object, core.StackTrace]],
       fork: [Zone, [], {pecificatio: ZoneSpecification, oneValue: core.Map}],
-      run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
-      runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
-      runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
-      registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
-      registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
-      registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
+      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])]],
       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, dart.dynamic, core.StackTrace]);
+  dart.fn(_rootHandleUncaughtError, dart.void, [Zone, ZoneDelegate, Zone, core.Object, 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, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
+  dart.fn(_rootRun, core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]);
   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, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]);
+  dart.fn(_rootRunUnary, core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom]), core.Object]);
   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, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]);
+  dart.fn(_rootRunBinary, core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]);
   function _rootRegisterCallback(self, parent, zone, f) {
     return f;
   }
-  dart.fn(_rootRegisterCallback, ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
+  dart.fn(_rootRegisterCallback, ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]);
   function _rootRegisterUnaryCallback(self, parent, zone, f) {
     return f;
   }
-  dart.fn(_rootRegisterUnaryCallback, ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]);
+  dart.fn(_rootRegisterUnaryCallback, ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom])]);
   function _rootRegisterBinaryCallback(self, parent, zone, f) {
     return f;
   }
-  dart.fn(_rootRegisterBinaryCallback, ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
+  dart.fn(_rootRegisterBinaryCallback, ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom])]);
   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(dart.dynamic, [])]);
+  dart.fn(_rootScheduleMicrotask, dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]);
   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 (core.identical(e, error)) {
             return parent.handleUncaughtError(zone, error, stackTrace);
           } else {
             return parent.handleUncaughtError(zone, e, s);
           }
         }
 
-      }, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
+      }, core.Object, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]);
     }
     if (zoneSpecification == null) {
       zoneSpecification = new ZoneSpecification({handleUncaughtError: errorHandler});
     } else if (errorHandler != null) {
       zoneSpecification = new 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, dart.dynamic, [dart.functionType(dart.dynamic, [])], {oneValue: core.Map, oneSpecificatio: ZoneSpecification, nErro: core.Function});
+  dart.fn(runZoned, core.Object, [dart.functionType(core.Object, [])], {oneValue: core.Map, oneSpecificatio: ZoneSpecification, nErro: core.Function});
   let __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.void, [Timer]));
-  let __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType38 = dart.typedef('__CastType38', () => dart.functionType(core.Object, [dart.bottom]));
   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;
 })(async, core, _internal, _js_helper, _isolate_helper, collection);