Initial support for runtime function types and type checking

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
   }
   // Function _registerErrorHandler: (Function, Zone) → Function
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return zone.registerBinaryCallback(errorHandler);
     } else {
-      return zone.registerUnaryCallback(dart.as(errorHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+      return zone.registerUnaryCallback(dart.as(errorHandler, dart.functionType(dynamic, [dynamic])));
     }
   }
   let _getBestStackTrace = Symbol('_getBestStackTrace');
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
       return this.error.toString();
@@ skipping 32 matching lines @@
   let _sink = Symbol('_sink');
   let Stream$ = dart.generic(function(T) {
     class Stream extends core.Object {
       Stream() {
       }
       fromFuture(future) {
         let controller = new (StreamController$(T))({sync: true});
         future.then(dart.as((value) => {
           controller[_add](dart.as(value, T));
           controller[_closeUnchecked]();
-        }, dart.throw_("Unimplemented type (T) → dynamic")), {
+        }, dart.functionType(dynamic, [T])), {
           onError: (error, stackTrace) => {
             controller[_addError](error, dart.as(stackTrace, core.StackTrace));
             controller[_closeUnchecked]();
           }
         });
         return controller.stream;
       }
       fromIterable(data) {
         return new (_GeneratedStreamImpl$(T))(() => new (_IterablePendingEvents$(T))(data));
       }
       periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation == null)
-          computation = dart.as((i) => null, dart.throw_("Unimplemented type (int) → T"));
+          computation = dart.as((i) => null, dart.functionType(T, [core.int]));
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         // Function sendEvent: () → void
         function sendEvent() {
           watch.reset();
           let data = computation(((x) => computationCount = dart.notNull(x) + 1, x)(computationCount));
           controller.add(data);
         }
@@ skipping 35 matching lines @@
       }
       eventTransformed(source, mapSink) {
         return dart.as(new _BoundSinkStream(source, dart.as(mapSink, _SinkMapper)), Stream$(T));
       }
       get isBroadcast() {
         return false;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
-        return new (_AsBroadcastStream$(T))(this, dart.as(onListen, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")), dart.as(onCancel, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")));
+        return new (_AsBroadcastStream$(T))(this, dart.as(onListen, dart.functionType(dart.void, [StreamSubscription])), dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription])));
       }
       where(test) {
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
         return new (_MapStream$(T, dynamic))(this, convert);
       }
       asyncMap(convert) {
         let controller = null;
         let subscription = null;
@@ skipping 109 matching lines @@
       }
       reduce(combine) {
         let result = new (_Future$(T))();
         let seenFirst = false;
         let value = null;
         let subscription = null;
         subscription = this.listen((element) => {
           if (seenFirst) {
             _runUserCode(() => combine(value, element), (newValue) => {
               value = newValue;
-            }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+            }, dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dynamic, [dynamic, core.StackTrace])));
           } else {
             value = element;
             seenFirst = true;
           }
         }, {
           onError: result[_completeError],
           onDone: () => {
             if (!dart.notNull(seenFirst)) {
               try {
                 throw _internal.IterableElementError.noElement();
@@ skipping 10 matching lines @@
         });
         return result;
       }
       fold(initialValue, combine) {
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => dart.dinvokef(combine, value, element), (newValue) => {
             value = newValue;
-          }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dynamic, [dynamic, core.StackTrace])));
         }, {
           onError: (e, st) => {
             result[_completeError](e, dart.as(st, core.StackTrace));
           },
           onDone: () => {
             result[_complete](value);
           },
           cancelOnError: true
         });
         return result;
@@ skipping 29 matching lines @@
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => dart.equals(element, needle), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dynamic, [dynamic, core.StackTrace])));
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](false);
           },
           cancelOnError: true
         });
         return future;
       }
       forEach(action) {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => action(element), (_) => {
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dynamic, [dynamic, core.StackTrace])));
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](null);
           },
           cancelOnError: true
         });
         return future;
       }
       every(test) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => test(element), (isMatch) => {
             if (!dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, false);
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dynamic, [dynamic, core.StackTrace])));
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](true);
           },
           cancelOnError: true
         });
         return future;
       }
       any(test) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => test(element), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dynamic, [dynamic, core.StackTrace])));
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](false);
           },
           cancelOnError: true
         });
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
         this.listen(dart.as((_) => {
           count = dart.notNull(count) + 1;
-        }, dart.throw_("Unimplemented type (T) → void")), {
+        }, dart.functionType(dart.void, [T])), {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](count);
           },
           cancelOnError: true
         });
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.as((_) => {
           _cancelAndValue(subscription, future, false);
-        }, dart.throw_("Unimplemented type (T) → void")), {
+        }, dart.functionType(dart.void, [T])), {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](true);
           },
           cancelOnError: true
         });
         return future;
       }
       toList() {
         let result = new core.List$(T).from([]);
@@ skipping 131 matching lines @@
       }
       firstWhere(test, opts) {
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((value) => {
           _runUserCode(() => test(value), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, value);
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dynamic, [dynamic, core.StackTrace])));
         }, {
           onError: future[_completeError],
           onDone: () => {
             if (defaultValue != null) {
               _runUserCode(defaultValue, future[_complete], future[_completeError]);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
@@ skipping 11 matching lines @@
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           _runUserCode(() => true == test(value), (isMatch) => {
             if (isMatch) {
               foundResult = true;
               result = value;
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dynamic, [dynamic, core.StackTrace])));
         }, {
           onError: future[_completeError],
           onDone: () => {
             if (foundResult) {
               future[_complete](result);
               return;
             }
             if (defaultValue != null) {
               _runUserCode(defaultValue, future[_complete], future[_completeError]);
               return;
@@ skipping 24 matching lines @@
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dynamic, [dynamic, core.StackTrace])));
         }, {
           onError: future[_completeError],
           onDone: () => {
             if (foundResult) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
@@ skipping 31 matching lines @@
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         let controller = null;
         let subscription = null;
         let timer = null;
         let zone = null;
         let timeout = null;
         // Function onData: (T) → void
         function onData(event) {
           timer.cancel();
           controller.add(event);
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
+          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         // Function onError: (dynamic, StackTrace) → void
         function onError(error, stackTrace) {
           timer.cancel();
           dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
           let eventSink = controller;
           dart.dinvoke(eventSink, '_addError', error, stackTrace);
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
+          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         // Function onDone: () → void
         function onDone() {
           timer.cancel();
           controller.close();
         }
         // Function onListen: () → void
         function onListen() {
           zone = Zone.current;
           if (onTimeout == null) {
             timeout = () => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
             };
           } else {
-            onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), dart.throw_("Unimplemented type (EventSink<dynamic>) → void"));
+            onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), dart.functionType(dart.void, [EventSink]));
             let wrapper = new _ControllerEventSinkWrapper(null);
             timeout = () => {
               wrapper[_sink] = controller;
               zone.runUnaryGuarded(onTimeout, wrapper);
               wrapper[_sink] = null;
             };
           }
           subscription = this.listen(onData, {onError: onError, onDone: onDone});
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
+          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         // Function onCancel: () → Future<dynamic>
         function onCancel() {
           timer.cancel();
           let result = subscription.cancel();
           subscription = null;
           return result;
         }
         controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, () => {
           timer.cancel();
           subscription.pause();
         }, () => {
           subscription.resume();
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
+          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }, onCancel);
         return controller.stream;
       }
     }
     dart.defineNamedConstructor(Stream, 'fromFuture');
     dart.defineNamedConstructor(Stream, 'fromIterable');
     dart.defineNamedConstructor(Stream, 'periodic');
     dart.defineNamedConstructor(Stream, 'eventTransformed');
     return Stream;
   });
@@ skipping 138 matching lines @@
         }
       }
       [_extractPending]() {
         dart.assert(this[_isCanceled]);
         let events = this[_pending];
         this[_pending] = null;
         return events;
       }
       onData(handleData) {
         if (handleData == null)
-          handleData = dart.as(_nullDataHandler, dart.throw_("Unimplemented type (T) → void"));
+          handleData = dart.as(_nullDataHandler, dart.functionType(dart.void, [T]));
         this[_onData] = dart.as(this[_zone].registerUnaryCallback(handleData), _DataHandler);
       }
       onError(handleError) {
         if (handleError == null)
           handleError = _nullErrorHandler;
         this[_onError] = _registerErrorHandler(handleError, this[_zone]);
       }
       onDone(handleDone) {
         if (handleDone == null)
           handleDone = _nullDoneHandler;
@@ skipping 166 matching lines @@
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         // Function sendError: () → void
         function sendError() {
           if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
           if (dart.is(this[_onError], ZoneBinaryCallback)) {
-            this[_zone].runBinaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic, dynamic) → dynamic")), error, stackTrace);
+            this[_zone].runBinaryGuarded(dart.as(this[_onError], dart.functionType(dynamic, [dynamic, dynamic])), error, stackTrace);
           } else {
-            this[_zone].runUnaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
+            this[_zone].runUnaryGuarded(dart.as(this[_onError], dart.functionType(dynamic, [dynamic])), error);
           }
           this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         }
         if (this[_cancelOnError]) {
           this[_state] = _BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL];
           this[_cancel]();
           if (dart.is(this[_cancelFuture], Future)) {
             this[_cancelFuture].whenComplete(sendError);
           } else {
             sendError();
@@ skipping 375 matching lines @@
         if (this[_isEmpty])
           return;
         this[_forEachListener]((subscription) => {
           subscription[_addError](error, stackTrace);
         });
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
           this[_forEachListener](dart.as((subscription) => {
             subscription[_close]();
-          }, dart.throw_("Unimplemented type (_BufferingStreamSubscription<T>) → void")));
+          }, dart.functionType(dart.void, [_BufferingStreamSubscription$(T)])));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
@@ skipping 289 matching lines @@
           if (!dart.notNull(iterator.moveNext()))
             return false;
           return new Future.sync(() => dart.dinvokef(f, iterator.current)).then((_) => true);
         });
       }
       static doWhile(f) {
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback((keepGoing) => {
           if (keepGoing) {
-            new Future.sync(f).then(dart.as(nextIteration, dart.throw_("Unimplemented type (dynamic) → dynamic")), {onError: doneSignal[_completeError]});
+            new Future.sync(f).then(dart.as(nextIteration, dart.functionType(dynamic, [dynamic])), {onError: doneSignal[_completeError]});
           } else {
             doneSignal[_complete](null);
           }
         }, {runGuarded: true});
         dart.dinvokef(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
@@ skipping 45 matching lines @@
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     result[_completeError](error, dart.as(stackTrace, core.StackTrace));
   }
   // Function _nonNullError: (Object) → Object
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
   let _FutureOnValue$ = dart.generic(function(T) {
-    class _FutureOnValue extends core.Function {}
+    let _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType(dynamic, [T]));
     return _FutureOnValue;
   });
   let _FutureOnValue = _FutureOnValue$();
-  class _FutureErrorTest extends core.Function {}
-  class _FutureAction extends core.Function {}
+  let _FutureErrorTest = dart.typedef('_FutureErrorTest', () => dart.functionType(core.bool, [dynamic]));
+  let _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(dynamic, []));
   let _Completer$ = dart.generic(function(T) {
     class _Completer extends core.Object {
       _Completer() {
         this.future = new (_Future$(T))();
       }
       completeError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this.future[_mayComplete]))
@@ skipping 188 matching lines @@
           this[_state] = _Future[_CHAINED];
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future[_INCOMPLETE];
         }
       }
       then(f, opts) {
         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), dart.throw_("Unimplemented type (T) → dynamic"));
+          f = dart.as(result[_zone].registerUnaryCallback(f), dart.functionType(dynamic, [T]));
           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;
         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), dart.throw_("Unimplemented type (dynamic) → bool"));
+            test = dart.as(result[_zone].registerUnaryCallback(test), dart.functionType(core.bool, [dynamic]));
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
         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));
@@ skipping 202 matching lines @@
                   return;
                 }
 
               }
               let errorCallback = listener[_onError];
               if (dart.notNull(matchesTest) && dart.notNull(errorCallback != null)) {
                 try {
                   if (dart.is(errorCallback, ZoneBinaryCallback)) {
                     listenerValueOrError = zone.runBinary(errorCallback, asyncError.error, asyncError.stackTrace);
                   } else {
-                    listenerValueOrError = zone.runUnary(dart.as(errorCallback, dart.throw_("Unimplemented type (dynamic) → dynamic")), asyncError.error);
+                    listenerValueOrError = zone.runUnary(dart.as(errorCallback, dart.functionType(dynamic, [dynamic])), asyncError.error);
                   }
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
                   return;
                 }
 
                 listenerHasValue = true;
               } else {
@@ skipping 122 matching lines @@
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
     _Future._INCOMPLETE = 0;
     _Future._PENDING_COMPLETE = 1;
     _Future._CHAINED = 2;
     _Future._VALUE = 4;
     _Future._ERROR = 8;
     return _Future;
   });
   let _Future = _Future$();
-  class _AsyncCallback extends core.Function {}
+  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;
   exports._isInCallbackLoop = false;
@@ skipping 557 matching lines @@
     }
     get [_onResume]() {
       return null;
     }
     get [_onCancel]() {
       return null;
     }
   }
   class _NoCallbackAsyncStreamController extends dart.mixin(_AsyncStreamControllerDispatch, _NoCallbacks) {}
   class _NoCallbackSyncStreamController extends dart.mixin(_SyncStreamControllerDispatch, _NoCallbacks) {}
-  class _NotificationHandler extends core.Function {}
+  let _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(dynamic, []));
   // Function _runGuarded: (() → dynamic) → Future<dynamic>
   function _runGuarded(notificationHandler) {
     if (notificationHandler == null)
       return null;
     try {
       let result = notificationHandler();
       if (dart.is(result, Future))
         return dart.as(result, Future);
       return null;
     } catch (e) {
@@ skipping 82 matching lines @@
   let _EventSink$ = dart.generic(function(T) {
     class _EventSink extends core.Object {}
     return _EventSink;
   });
   let _EventSink = _EventSink$();
   let _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {}
     return _EventDispatch;
   });
   let _EventDispatch = _EventDispatch$();
-  class _EventGenerator extends core.Function {}
+  let _EventGenerator = dart.typedef('_EventGenerator', () => dart.functionType(_PendingEvents, []));
   let _isUsed = Symbol('_isUsed');
   let _GeneratedStreamImpl$ = dart.generic(function(T) {
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
       _GeneratedStreamImpl(pending$) {
         this[_pending] = pending$;
         this[_isUsed] = false;
         super._StreamImpl();
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         if (this[_isUsed])
@@ skipping 81 matching lines @@
       clear() {
         if (this.isScheduled)
           this.cancelSchedule();
         this[_iterator] = null;
       }
     }
     return _IterablePendingEvents;
   });
   let _IterablePendingEvents = _IterablePendingEvents$();
   let _DataHandler$ = dart.generic(function(T) {
-    class _DataHandler extends core.Function {}
+    let _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart.void, [T]));
     return _DataHandler;
   });
   let _DataHandler = _DataHandler$();
-  class _DoneHandler extends core.Function {}
+  let _DoneHandler = dart.typedef('_DoneHandler', () => dart.functionType(dart.void, []));
   // Function _nullDataHandler: (dynamic) → void
   function _nullDataHandler(value) {
   }
   // Function _nullErrorHandler: (dynamic, [StackTrace]) → void
   function _nullErrorHandler(error, stackTrace) {
     if (stackTrace === void 0)
       stackTrace = null;
     Zone.current.handleUncaughtError(error, stackTrace);
   }
   // Function _nullDoneHandler: () → void
@@ skipping 85 matching lines @@
       this[_next] = this[_previous] = this;
     }
     [_insertBefore](newNext) {
       let newPrevious = newNext[_previous];
       newPrevious[_next] = this;
       newNext[_previous] = this[_previous];
       this[_previous][_next] = newNext;
       this[_previous] = newPrevious;
     }
   }
-  class _broadcastCallback extends core.Function {}
+  let _broadcastCallback = dart.typedef('_broadcastCallback', () => dart.functionType(dart.void, [StreamSubscription]));
   let _schedule = Symbol('_schedule');
   let _isSent = Symbol('_isSent');
   let _DONE_SENT = Symbol('_DONE_SENT');
   let _isScheduled = Symbol('_isScheduled');
   let _SCHEDULED = Symbol('_SCHEDULED');
   let _PAUSED = Symbol('_PAUSED');
   let _DoneStreamSubscription$ = dart.generic(function(T) {
     class _DoneStreamSubscription extends core.Object {
       _DoneStreamSubscription(onDone$) {
         this[_onDone] = onDone$;
@@ skipping 434 matching lines @@
         this[_stream][_handleError](error, stackTrace, this);
       }
       [_handleDone]() {
         this[_stream][_handleDone](this);
       }
     }
     return _ForwardingStreamSubscription;
   });
   let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
   let _Predicate$ = dart.generic(function(T) {
-    class _Predicate extends core.Function {}
+    let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _Predicate = _Predicate$();
   // Function _addErrorWithReplacement: (_EventSink<dynamic>, dynamic, dynamic) → void
   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;
     }
@@ skipping 18 matching lines @@
 
         if (satisfies) {
           sink[_add](inputEvent);
         }
       }
     }
     return _WhereStream;
   });
   let _WhereStream = _WhereStream$();
   let _Transformation$ = dart.generic(function(S, T) {
-    class _Transformation extends core.Function {}
+    let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
   let _transform = Symbol('_transform');
   let _MapStream$ = dart.generic(function(S, T) {
     class _MapStream extends _ForwardingStream$(S, T) {
       _MapStream(source, transform) {
         this[_transform] = transform;
         super._ForwardingStream(source);
       }
@@ skipping 28 matching lines @@
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
         }
 
       }
     }
     return _ExpandStream;
   });
   let _ExpandStream = _ExpandStream$();
-  class _ErrorTest extends core.Function {}
+  let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dynamic]));
   let _HandleErrorStream$ = dart.generic(function(T) {
     class _HandleErrorStream extends _ForwardingStream$(T, T) {
       _HandleErrorStream(source, onError, test) {
         this[_transform] = onError;
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleError](error, stackTrace, sink) {
         let matches = true;
         if (this[_test] != null) {
@@ skipping 121 matching lines @@
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
           sink[_add](inputEvent);
         }
       }
     }
     return _SkipWhileStream;
   });
   let _SkipWhileStream = _SkipWhileStream$();
   let _Equality$ = dart.generic(function(T) {
-    class _Equality extends core.Function {}
+    let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
     return _Equality;
   });
   let _Equality = _Equality$();
   let _SENTINEL = Symbol('_SENTINEL');
   let _equals = Symbol('_equals');
   let _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
         this[_previous] = _DistinctStream[_SENTINEL];
         this[_equals] = equals;
@@ skipping 135 matching lines @@
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
     }
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
   let _SinkMapper$ = dart.generic(function(S, T) {
-    class _SinkMapper extends core.Function {}
+    let _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
     return _SinkMapper;
   });
   let _SinkMapper = _SinkMapper$();
   let _sinkMapper = Symbol('_sinkMapper');
   let _StreamSinkTransformer$ = dart.generic(function(S, T) {
     class _StreamSinkTransformer extends core.Object {
       _StreamSinkTransformer(sinkMapper) {
         this[_sinkMapper] = sinkMapper;
       }
       bind(stream) {
@@ skipping 20 matching lines @@
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let subscription = new _SinkTransformerStreamSubscription(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$();
   let _TransformDataHandler$ = dart.generic(function(S, T) {
-    class _TransformDataHandler extends core.Function {}
+    let _TransformDataHandler = dart.typedef('_TransformDataHandler', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return _TransformDataHandler;
   });
   let _TransformDataHandler = _TransformDataHandler$();
   let _TransformErrorHandler$ = dart.generic(function(T) {
-    class _TransformErrorHandler extends core.Function {}
+    let _TransformErrorHandler = dart.typedef('_TransformErrorHandler', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
     return _TransformErrorHandler;
   });
   let _TransformErrorHandler = _TransformErrorHandler$();
   let _TransformDoneHandler$ = dart.generic(function(T) {
-    class _TransformDoneHandler extends core.Function {}
+    let _TransformDoneHandler = dart.typedef('_TransformDoneHandler', () => dart.functionType(dart.void, [EventSink$(T)]));
     return _TransformDoneHandler;
   });
   let _TransformDoneHandler = _TransformDoneHandler$();
   let _HandlerEventSink$ = dart.generic(function(S, T) {
     class _HandlerEventSink extends core.Object {
       _HandlerEventSink(handleData$, handleError$, handleDone$, sink$) {
         this[_handleData] = handleData$;
         this[_handleError] = handleError$;
         this[_handleDone] = handleDone$;
         this[_sink] = sink$;
@@ skipping 18 matching lines @@
   let _defaultHandleError = Symbol('_defaultHandleError');
   let _defaultHandleDone = Symbol('_defaultHandleDone');
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opts) {
         let handleData = opts && 'handleData' in opts ? opts.handleData : null;
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
         super._StreamSinkTransformer(dart.as((outputSink) => {
           if (handleData == null)
-            handleData = dart.as(_StreamHandlerTransformer[_defaultHandleData], dart.throw_("Unimplemented type (S, EventSink<T>) → void"));
+            handleData = dart.as(_StreamHandlerTransformer[_defaultHandleData], dart.functionType(dart.void, [S, EventSink$(T)]));
           if (handleError == null)
-            handleError = dart.as(_StreamHandlerTransformer[_defaultHandleError], dart.throw_("Unimplemented type (Object, StackTrace, EventSink<T>) → void"));
+            handleError = dart.as(_StreamHandlerTransformer[_defaultHandleError], dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
           if (handleDone == null)
             handleDone = _StreamHandlerTransformer[_defaultHandleDone];
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
         }, _SinkMapper));
       }
       bind(stream) {
         return super.bind(stream);
       }
       static [_defaultHandleData](data, sink) {
         sink.add(data);
       }
       static [_defaultHandleError](error, stackTrace, sink) {
         sink.addError(error);
       }
       static [_defaultHandleDone](sink) {
         sink.close();
       }
     }
     return _StreamHandlerTransformer;
   });
   let _StreamHandlerTransformer = _StreamHandlerTransformer$();
   let _SubscriptionTransformer$ = dart.generic(function(S, T) {
-    class _SubscriptionTransformer extends core.Function {}
+    let _SubscriptionTransformer = dart.typedef('_SubscriptionTransformer', () => dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool]));
     return _SubscriptionTransformer;
   });
   let _SubscriptionTransformer = _SubscriptionTransformer$();
   let _transformer = Symbol('_transformer');
   let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
     class _StreamSubscriptionTransformer extends core.Object {
       _StreamSubscriptionTransformer(transformer$) {
         this[_transformer] = transformer$;
       }
       bind(stream) {
@@ skipping 31 matching lines @@
     Timer(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createTimer(duration, callback);
       }
       return Zone.current.createTimer(duration, Zone.current.bindCallback(callback, {runGuarded: true}));
     }
     periodic(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createPeriodicTimer(duration, callback);
       }
-      return Zone.current.createPeriodicTimer(duration, dart.as(Zone.current.bindUnaryCallback(callback, {runGuarded: true}), dart.throw_("Unimplemented type (Timer) → void")));
+      return Zone.current.createPeriodicTimer(duration, dart.as(Zone.current.bindUnaryCallback(callback, {runGuarded: true}), dart.functionType(dart.void, [Timer])));
     }
     static run(callback) {
       new Timer(core.Duration.ZERO, callback);
     }
     static [_createTimer](duration, callback) {
       let milliseconds = duration.inMilliseconds;
       if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl(milliseconds, callback);
     }
     static [_createPeriodicTimer](duration, callback) {
       let milliseconds = duration.inMilliseconds;
       if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl.periodic(milliseconds, callback);
     }
   }
   dart.defineNamedConstructor(Timer, 'periodic');
-  class ZoneCallback extends core.Function {}
-  class ZoneUnaryCallback extends core.Function {}
-  class ZoneBinaryCallback extends core.Function {}
-  class HandleUncaughtErrorHandler extends core.Function {}
-  class RunHandler extends core.Function {}
-  class RunUnaryHandler extends core.Function {}
-  class RunBinaryHandler extends core.Function {}
-  class RegisterCallbackHandler extends core.Function {}
-  class RegisterUnaryCallbackHandler extends core.Function {}
-  class RegisterBinaryCallbackHandler extends core.Function {}
-  class ErrorCallbackHandler extends core.Function {}
-  class ScheduleMicrotaskHandler extends core.Function {}
-  class CreateTimerHandler extends core.Function {}
-  class CreatePeriodicTimerHandler extends core.Function {}
-  class PrintHandler extends core.Function {}
-  class ForkHandler extends core.Function {}
+  let ZoneCallback = dart.typedef('ZoneCallback', () => dart.functionType(dynamic, []));
+  let ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionType(dynamic, [dynamic]));
+  let ZoneBinaryCallback = dart.typedef('ZoneBinaryCallback', () => dart.functionType(dynamic, [dynamic, dynamic]));
+  let HandleUncaughtErrorHandler = dart.typedef('HandleUncaughtErrorHandler', () => dart.functionType(dynamic, [Zone, ZoneDelegate, Zone, dynamic, core.StackTrace]));
+  let RunHandler = dart.typedef('RunHandler', () => dart.functionType(dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [])]));
+  let RunUnaryHandler = dart.typedef('RunUnaryHandler', () => dart.functionType(dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [dynamic]), dynamic]));
+  let RunBinaryHandler = dart.typedef('RunBinaryHandler', () => dart.functionType(dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [dynamic, dynamic]), dynamic, dynamic]));
+  let RegisterCallbackHandler = dart.typedef('RegisterCallbackHandler', () => dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [])]));
+  let RegisterUnaryCallbackHandler = dart.typedef('RegisterUnaryCallbackHandler', () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [dynamic])]));
+  let RegisterBinaryCallbackHandler = dart.typedef('RegisterBinaryCallbackHandler', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [dynamic, dynamic])]));
+  let ErrorCallbackHandler = dart.typedef('ErrorCallbackHandler', () => dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]));
+  let ScheduleMicrotaskHandler = dart.typedef('ScheduleMicrotaskHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [])]));
+  let CreateTimerHandler = dart.typedef('CreateTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]));
+  let CreatePeriodicTimerHandler = dart.typedef('CreatePeriodicTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]));
+  let PrintHandler = dart.typedef('PrintHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]));
+  let ForkHandler = dart.typedef('ForkHandler', () => dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]));
   class _ZoneFunction extends core.Object {
     _ZoneFunction(zone, func) {
       this.zone = zone;
       this.function = func;
     }
   }
   class ZoneSpecification extends core.Object {
     ZoneSpecification(opts) {
       return new _ZoneSpecification(opts);
     }
     from(other, opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
       let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
       let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
       let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.createPeriodicTimer : null;
       let print = opts && 'print' in opts ? opts.print : null;
       let fork = opts && 'fork' in opts ? opts.fork : null;
-      return new ZoneSpecification({handleUncaughtError: dart.as(handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → dynamic")), run: dart.as(run != null ? run : other.run, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic")), runUnary: dart.as(runUnary != null ? runUnary : other.runUnary, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic")), runBinary: dart.as(runBinary != null ? runBinary : other.runBinary, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic")), registerCallback: dart.as(registerCallback != null ? registerCallback : other.registerCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback")), registerUnaryCallback: dart.as(registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → ZoneUnaryCallback")), registerBinaryCallback: dart.as(registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic) → ZoneBinaryCallback")), errorCallback: dart.as(errorCallback != null ? errorCallback : other.errorCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, Object, StackTrace) → AsyncError")), scheduleMicrotask: dart.as(scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, () → dynamic) → void")), createTimer: dart.as(createTimer != null ? createTimer : other.createTimer, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer")), createPeriodicTimer: dart.as(createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, Duration, (Timer) → void) → Timer")), print: dart.as(print != null ? print : other.print, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, String) → void")), fork: dart.as(fork != null ? fork : other.fork, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, ZoneSpecification, Map<dynamic, dynamic>) → Zone"))});
+      return new ZoneSpecification({handleUncaughtError: dart.as(handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, dart.functionType(dynamic, [Zone, ZoneDelegate, Zone, dynamic, core.StackTrace])), run: dart.as(run != null ? run : other.run, dart.functionType(dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [])])), runUnary: dart.as(runUnary != null ? runUnary : other.runUnary, dart.functionType(dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [dynamic]), dynamic])), runBinary: dart.as(runBinary != null ? runBinary : other.runBinary, dart.functionType(dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [dynamic, dynamic]), dynamic, dynamic])), registerCallback: dart.as(registerCallback != null ? registerCallback : other.registerCallback, dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [])])), registerUnaryCallback: dart.as(registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [dynamic])])), registerBinaryCallback: dart.as(registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [dynamic, dynamic])])), errorCallback: dart.as(errorCallback != null ? errorCallback : other.errorCallback, dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace])), scheduleMicrotask: dart.as(scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dynamic, [])])), createTimer: dart.as(createTimer != null ? createTimer : other.createTimer, dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])])), createPeriodicTimer: dart.as(createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])])), print: dart.as(print != null ? print : other.print, dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String])), fork: dart.as(fork != null ? fork : other.fork, dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]))});
     }
   }
   dart.defineNamedConstructor(ZoneSpecification, 'from');
   class _ZoneSpecification extends core.Object {
     _ZoneSpecification(opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
@@ skipping 406 matching lines @@
   // Function _rootCreateTimer: (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer
   function _rootCreateTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
       callback = zone.bindCallback(callback);
     }
     return Timer[_createTimer](duration, callback);
   }
   // Function _rootCreatePeriodicTimer: (Zone, ZoneDelegate, Zone, Duration, (Timer) → void) → Timer
   function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
-      callback = dart.as(zone.bindUnaryCallback(callback), dart.throw_("Unimplemented type (Timer) → void"));
+      callback = dart.as(zone.bindUnaryCallback(callback), dart.functionType(dart.void, [Timer]));
     }
     return Timer[_createPeriodicTimer](duration, callback);
   }
   // Function _rootPrint: (Zone, ZoneDelegate, Zone, String) → void
   function _rootPrint(self, parent, zone, line) {
     _internal.printToConsole(line);
   }
   // Function _printToZone: (String) → void
   function _printToZone(line) {
     Zone.current.print(line);
@@ skipping 243 matching lines @@
     let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
     let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
     let onError = opts && 'onError' in opts ? opts.onError : null;
     let errorHandler = null;
     if (onError != null) {
       errorHandler = (self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
             return self.parent.runBinary(onError, error, stackTrace);
           }
-          return self.parent.runUnary(dart.as(onError, dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
+          return self.parent.runUnary(dart.as(onError, dart.functionType(dynamic, [dynamic])), 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);
           }
         }
 
       };
@@ skipping 58 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));