keep mixin and interface implementation info at runtime

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")));
     }
   }
   let _getBestStackTrace = Symbol('_getBestStackTrace');
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
       return dart.as(dart.dinvoke(this.error, 'toString'), core.String);
     }
   }
+  AsyncError[dart.implements] = [core.Error];
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _UncaughtAsyncError[_getBestStackTrace](error, stackTrace));
     }
     static [_getBestStackTrace](error, stackTrace) {
       if (stackTrace !== null)
         return stackTrace;
       if (dart.is(error, core.Error)) {
         return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
       }
@@ skipping 1030 matching lines @@
             this[_onResume]();
           }
           this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
           wasInputPaused = isInputPaused;
         }
         if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
           this[_pending].schedule(this);
         }
       }
     }
+    _BufferingStreamSubscription[dart.implements] = [StreamSubscription$(T), _EventSink$(T), _EventDispatch$(T)];
     _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
     _BufferingStreamSubscription._STATE_CLOSED = 2;
     _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
     _BufferingStreamSubscription._STATE_CANCELED = 8;
     _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
     _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
     _BufferingStreamSubscription._STATE_HAS_PENDING = 64;
     _BufferingStreamSubscription._STATE_PAUSE_COUNT = 128;
     _BufferingStreamSubscription._STATE_PAUSE_COUNT_SHIFT = 7;
     return _BufferingStreamSubscription;
@@ skipping 42 matching lines @@
       [_setRemoveAfterFiring]() {
         dart.assert(this[_isFiring]);
         this[_eventState] = _BroadcastSubscription[_STATE_REMOVE_AFTER_FIRING];
       }
       get [_removeAfterFiring]() {
         return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription[_STATE_REMOVE_AFTER_FIRING])) !== 0;
       }
       [_onPause]() {}
       [_onResume]() {}
     }
+    _BroadcastSubscription[dart.implements] = [_BroadcastSubscriptionLink];
     _BroadcastSubscription._STATE_EVENT_ID = 1;
     _BroadcastSubscription._STATE_FIRING = 2;
     _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$(dart.dynamic);
   let _STATE_INITIAL = Symbol('_STATE_INITIAL');
   let _addStreamState = Symbol('_addStreamState');
   let _doneFuture = Symbol('_doneFuture');
   let _isEmpty = Symbol('_isEmpty');
@@ skipping 198 matching lines @@
         }
       }
       [_callOnCancel]() {
         dart.assert(this[_isEmpty]);
         if (dart.notNull(this.isClosed) && dart.notNull(this[_doneFuture][_mayComplete])) {
           this[_doneFuture]._asyncComplete(null);
         }
         _runGuarded(this[_onCancel]);
       }
     }
+    _BroadcastStreamController[dart.implements] = [StreamController$(T), _StreamControllerLifecycle$(T), _BroadcastSubscriptionLink, _EventSink$(T), _EventDispatch$(T)];
     _BroadcastStreamController._STATE_INITIAL = 0;
     _BroadcastStreamController._STATE_EVENT_ID = 1;
     _BroadcastStreamController._STATE_FIRING = 2;
     _BroadcastStreamController._STATE_CLOSED = 4;
     _BroadcastStreamController._STATE_ADDSTREAM = 8;
     return _BroadcastStreamController;
   });
   let _BroadcastStreamController = _BroadcastStreamController$(dart.dynamic);
   let _SyncBroadcastStreamController$ = dart.generic(function(T) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
@@ skipping 123 matching lines @@
         return result;
       }
       [_callOnCancel]() {
         if (this[_hasPending]) {
           this[_pending].clear();
           this[_pending] = null;
         }
         super._callOnCancel();
       }
     }
+    _AsBroadcastStreamController[dart.implements] = [_EventDispatch$(T)];
     return _AsBroadcastStreamController;
   });
   let _AsBroadcastStreamController = _AsBroadcastStreamController$(dart.dynamic);
   let _pauseCount = Symbol('_pauseCount');
   let _resume = Symbol('_resume');
   let _DoneSubscription$ = dart.generic(function(T) {
     class _DoneSubscription extends core.Object {
       _DoneSubscription() {
         this[_pauseCount] = 0;
       }
@@ skipping 19 matching lines @@
       }
       get isPaused() {
         return dart.notNull(this[_pauseCount]) > 0;
       }
       asFuture(value) {
         if (value === void 0)
           value = null;
         return new _Future();
       }
     }
+    _DoneSubscription[dart.implements] = [StreamSubscription$(T)];
     return _DoneSubscription;
   });
   let _DoneSubscription = _DoneSubscription$(dart.dynamic);
   class DeferredLibrary extends core.Object {
     DeferredLibrary(libraryName, opts) {
       let uri = opts && 'uri' in opts ? opts.uri : null;
       this.libraryName = libraryName;
       this.uri = uri;
     }
     load() {
       throw 'DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.';
     }
   }
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s$) {
       this[_s] = s$;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
+  DeferredLoadException[dart.implements] = [core.Exception];
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new _Future();
         Timer.run((() => {
           try {
             result._complete(computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
@@ skipping 161 matching lines @@
     }
     toString() {
       let result = "TimeoutException";
       if (this.duration !== null)
         result = `TimeoutException after ${this.duration}`;
       if (this.message !== null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
+  TimeoutException[dart.implements] = [core.Exception];
   let Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       Completer() {
         return new _AsyncCompleter();
       }
       sync() {
         return new _SyncCompleter();
       }
     }
     dart.defineNamedConstructor(Completer, 'sync');
@@ skipping 28 matching lines @@
         if (replacement !== null) {
           error = _nonNullError(replacement.error);
           stackTrace = replacement.stackTrace;
         }
         this[_completeError](error, stackTrace);
       }
       get isCompleted() {
         return !dart.notNull(this.future[_mayComplete]);
       }
     }
+    _Completer[dart.implements] = [Completer$(T)];
     return _Completer;
   });
   let _Completer = _Completer$(dart.dynamic);
   let _AsyncCompleter$ = dart.generic(function(T) {
     class _AsyncCompleter extends _Completer$(T) {
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
@@ skipping 530 matching lines @@
           }
         }).bind(this), {onError: ((e, s) => {
             if (timer.isActive) {
               timer.cancel();
               result._completeError(e, dart.as(s, core.StackTrace));
             }
           }).bind(this)});
         return result;
       }
     }
+    _Future[dart.implements] = [Future$(T)];
     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$(dart.dynamic);
@@ skipping 139 matching lines @@
   });
   let StreamSubscription$ = dart.generic(function(T) {
     class StreamSubscription extends core.Object {
     }
     return StreamSubscription;
   });
   let StreamSubscription = StreamSubscription$(dart.dynamic);
   let EventSink$ = dart.generic(function(T) {
     class EventSink extends core.Object {
     }
+    EventSink[dart.implements] = [core.Sink$(T)];
     return EventSink;
   });
   let EventSink = EventSink$(dart.dynamic);
   let _stream = Symbol('_stream');
   let StreamView$ = dart.generic(function(T) {
     class StreamView extends Stream$(T) {
       StreamView(stream$) {
         this[_stream] = stream$;
         super.Stream();
       }
@@ skipping 17 matching lines @@
   let StreamView = StreamView$(dart.dynamic);
   let StreamConsumer$ = dart.generic(function(S) {
     class StreamConsumer extends core.Object {
     }
     return StreamConsumer;
   });
   let StreamConsumer = StreamConsumer$(dart.dynamic);
   let StreamSink$ = dart.generic(function(S) {
     class StreamSink extends core.Object {
     }
+    StreamSink[dart.implements] = [StreamConsumer$(S), EventSink$(S)];
     return StreamSink;
   });
   let StreamSink = StreamSink$(dart.dynamic);
   let StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       StreamTransformer(transformer) {
         return new _StreamSubscriptionTransformer(transformer);
       }
       fromHandlers(opts) {
         return new _StreamHandlerTransformer(opts);
@@ skipping 22 matching lines @@
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_sink].addError(error, stackTrace);
       }
       close() {
         this[_sink].close();
       }
     }
+    _ControllerEventSinkWrapper[dart.implements] = [EventSink$(T)];
     return _ControllerEventSinkWrapper;
   });
   let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$(dart.dynamic);
   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;
         if (dart.notNull(onListen === null) && dart.notNull(onPause === null) && dart.notNull(onResume === null) && dart.notNull(onCancel === null)) {
           return dart.as(sync ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
         }
         return sync ? new _SyncStreamController(onListen, onPause, onResume, onCancel) : new _AsyncStreamController(onListen, onPause, onResume, onCancel);
       }
       broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         return sync ? new _SyncBroadcastStreamController(onListen, onCancel) : new _AsyncBroadcastStreamController(onListen, onCancel);
       }
     }
+    StreamController[dart.implements] = [StreamSink$(T)];
     dart.defineNamedConstructor(StreamController, 'broadcast');
     return StreamController;
   });
   let StreamController = StreamController$(dart.dynamic);
   let _StreamControllerLifecycle$ = dart.generic(function(T) {
     class _StreamControllerLifecycle extends core.Object {
       [_recordPause](subscription) {}
       [_recordResume](subscription) {}
       [_recordCancel](subscription) {
         return null;
@@ skipping 222 matching lines @@
         _runGuarded(this[_onPause]);
       }
       [_recordResume](subscription) {
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.resume();
         }
         _runGuarded(this[_onResume]);
       }
     }
+    _StreamController[dart.implements] = [StreamController$(T), _StreamControllerLifecycle$(T), _EventSink$(T), _EventDispatch$(T)];
     _StreamController._STATE_INITIAL = 0;
     _StreamController._STATE_SUBSCRIBED = 1;
     _StreamController._STATE_CANCELED = 2;
     _StreamController._STATE_SUBSCRIPTION_MASK = 3;
     _StreamController._STATE_CLOSED = 4;
     _StreamController._STATE_ADDSTREAM = 8;
     return _StreamController;
   });
   let _StreamController = _StreamController$(dart.dynamic);
   let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _SyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         this[_subscription]._add(data);
       }
       [_sendError](error, stackTrace) {
         this[_subscription]._addError(error, stackTrace);
       }
       [_sendDone]() {
         this[_subscription]._close();
       }
     }
+    _SyncStreamControllerDispatch[dart.implements] = [_StreamController$(T)];
     return _SyncStreamControllerDispatch;
   });
   let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$(dart.dynamic);
   let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _AsyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         this[_subscription]._addPending(new _DelayedData(data));
       }
       [_sendError](error, stackTrace) {
         this[_subscription]._addPending(new _DelayedError(error, stackTrace));
       }
       [_sendDone]() {
         this[_subscription]._addPending(new _DelayedDone());
       }
     }
+    _AsyncStreamControllerDispatch[dart.implements] = [_StreamController$(T)];
     return _AsyncStreamControllerDispatch;
   });
   let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$(dart.dynamic);
   let _AsyncStreamController$ = dart.generic(function(T) {
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
       _AsyncStreamController(onListen$, onPause$, onResume$, onCancel$) {
         this[_onListen] = onListen$;
         this[_onPause] = onPause$;
         this[_onResume] = onResume$;
         this[_onCancel] = onCancel$;
@@ skipping 67 matching lines @@
         return this[_target].close();
       }
       addStream(source, opts) {
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         return this[_target].addStream(source, {cancelOnError: cancelOnError});
       }
       get done() {
         return this[_target].done;
       }
     }
+    _StreamSinkWrapper[dart.implements] = [StreamSink$(T)];
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$(dart.dynamic);
   let _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
         this.addSubscription = source.listen(controller[_add], {onError: dart.as(cancelOnError ? _AddStreamState.makeErrorHandler(controller) : controller[_addError], core.Function), onDone: controller[_close], cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
@@ skipping 196 matching lines @@
     perform(dispatch) {
       dispatch._sendDone();
     }
     get next() {
       return null;
     }
     set next(_) {
       throw new core.StateError("No events after a done.");
     }
   }
+  _DelayedDone[dart.implements] = [_DelayedEvent];
   class _StreamImplEvents extends _PendingEvents {
     _StreamImplEvents() {
       this.firstPendingEvent = null;
       this.lastPendingEvent = null;
       super._PendingEvents();
     }
     get isEmpty() {
       return this.lastPendingEvent === null;
     }
     add(event) {
@@ skipping 101 matching lines @@
       }
       [_sendDone]() {
         this[_state] = ~dart.notNull(_DoneStreamSubscription[_SCHEDULED]);
         if (this.isPaused)
           return;
         this[_state] = _DoneStreamSubscription[_DONE_SENT];
         if (this[_onDone] !== null)
           this[_zone].runGuarded(this[_onDone]);
       }
     }
+    _DoneStreamSubscription[dart.implements] = [StreamSubscription$(T)];
     _DoneStreamSubscription._DONE_SENT = 1;
     _DoneStreamSubscription._SCHEDULED = 2;
     _DoneStreamSubscription._PAUSED = 4;
     return _DoneStreamSubscription;
   });
   let _DoneStreamSubscription = _DoneStreamSubscription$(dart.dynamic);
   let _source = Symbol('_source');
   let _onListenHandler = Symbol('_onListenHandler');
   let _onCancelHandler = Symbol('_onCancelHandler');
   let _cancelSubscription = Symbol('_cancelSubscription');
@@ skipping 100 matching lines @@
       }
       get isPaused() {
         return this[_stream][_isSubscriptionPaused];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
     }
+    _BroadcastSubscriptionWrapper[dart.implements] = [StreamSubscription$(T)];
     return _BroadcastSubscriptionWrapper;
   });
   let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$(dart.dynamic);
   let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
   let _STATE_FOUND = Symbol('_STATE_FOUND');
   let _STATE_DONE = Symbol('_STATE_DONE');
   let _STATE_MOVING = Symbol('_STATE_MOVING');
   let _STATE_EXTRA_DATA = Symbol('_STATE_EXTRA_DATA');
   let _STATE_EXTRA_ERROR = Symbol('_STATE_EXTRA_ERROR');
@@ skipping 98 matching lines @@
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
           hasNext._complete(false);
           return;
         }
         this[_subscription].pause();
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl[_STATE_EXTRA_DONE];
       }
     }
+    _StreamIteratorImpl[dart.implements] = [StreamIterator$(T)];
     _StreamIteratorImpl._STATE_FOUND = 0;
     _StreamIteratorImpl._STATE_DONE = 1;
     _StreamIteratorImpl._STATE_MOVING = 2;
     _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
     _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
     _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
     return _StreamIteratorImpl;
   });
   let _StreamIteratorImpl = _StreamIteratorImpl$(dart.dynamic);
   // Function _runUserCode: (() → dynamic, (dynamic) → dynamic, (dynamic, StackTrace) → dynamic) → dynamic
@@ skipping 401 matching lines @@
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_sink]._addError(error, stackTrace);
       }
       close() {
         this[_sink]._close();
       }
     }
+    _EventSinkWrapper[dart.implements] = [EventSink$(T)];
     return _EventSinkWrapper;
   });
   let _EventSinkWrapper = _EventSinkWrapper$(dart.dynamic);
   let _transformerSink = Symbol('_transformerSink');
   let _isSubscribed = Symbol('_isSubscribed');
   let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
     class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
       _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
         this[_transformerSink] = null;
         this[_subscription] = null;
@@ skipping 80 matching lines @@
   let _sinkMapper = Symbol('_sinkMapper');
   let _StreamSinkTransformer$ = dart.generic(function(S, T) {
     class _StreamSinkTransformer extends core.Object {
       _StreamSinkTransformer(sinkMapper) {
         this[_sinkMapper] = sinkMapper;
       }
       bind(stream) {
         return new _BoundSinkStream(stream, this[_sinkMapper]);
       }
     }
+    _StreamSinkTransformer[dart.implements] = [StreamTransformer$(S, T)];
     return _StreamSinkTransformer;
   });
   let _StreamSinkTransformer = _StreamSinkTransformer$(dart.dynamic, dart.dynamic);
   let _BoundSinkStream$ = dart.generic(function(S, T) {
     class _BoundSinkStream extends Stream$(T) {
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
       _BoundSinkStream(stream$, sinkMapper) {
         this[_stream] = stream$;
@@ skipping 25 matching lines @@
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         return this[_handleError](error, stackTrace, this[_sink]);
       }
       close() {
         return this[_handleDone](this[_sink]);
       }
     }
+    _HandlerEventSink[dart.implements] = [EventSink$(S)];
     return _HandlerEventSink;
   });
   let _HandlerEventSink = _HandlerEventSink$(dart.dynamic, dart.dynamic);
   let _defaultHandleData = Symbol('_defaultHandleData');
   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;
@@ skipping 28 matching lines @@
   let _transformer = Symbol('_transformer');
   let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
     class _StreamSubscriptionTransformer extends core.Object {
       _StreamSubscriptionTransformer(transformer$) {
         this[_transformer] = transformer$;
       }
       bind(stream) {
         return new _BoundSubscriptionStream(stream, this[_transformer]);
       }
     }
+    _StreamSubscriptionTransformer[dart.implements] = [StreamTransformer$(S, T)];
     return _StreamSubscriptionTransformer;
   });
   let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$(dart.dynamic, dart.dynamic);
   let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
     class _BoundSubscriptionStream extends Stream$(T) {
       _BoundSubscriptionStream(stream$, transformer$) {
         this[_stream] = stream$;
         this[_transformer] = transformer$;
         super.Stream();
       }
@@ skipping 95 matching lines @@
       this.registerUnaryCallback = registerUnaryCallback;
       this.registerBinaryCallback = registerBinaryCallback;
       this.errorCallback = errorCallback;
       this.scheduleMicrotask = scheduleMicrotask;
       this.createTimer = createTimer;
       this.createPeriodicTimer = createPeriodicTimer;
       this.print = print;
       this.fork = fork;
     }
   }
+  _ZoneSpecification[dart.implements] = [ZoneSpecification];
   class ZoneDelegate extends core.Object {
   }
   let _$ = Symbol('_');
   let _enter = Symbol('_enter');
   let _leave = Symbol('_leave');
   class Zone extends core.Object {
     [_$]() {
     }
     static get current() {
       return Zone[_current];
@@ skipping 97 matching lines @@
       let implementation = this[_delegationTarget][_print];
       let implZone = implementation.zone;
       dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, line);
     }
     fork(zone, specification, zoneValues) {
       let implementation = this[_delegationTarget][_fork];
       let implZone = implementation.zone;
       return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
     }
   }
+  _ZoneDelegate[dart.implements] = [ZoneDelegate];
   class _Zone extends core.Object {
     _Zone() {
     }
     inSameErrorZone(otherZone) {
       return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
     }
   }
+  _Zone[dart.implements] = [Zone];
   let _delegateCache = Symbol('_delegateCache');
   let _map = Symbol('_map');
   class _CustomZone extends _Zone {
     get [_delegate]() {
       if (this[_delegateCache] !== null)
         return this[_delegateCache];
       this[_delegateCache] = new _ZoneDelegate(this);
       return this[_delegateCache];
     }
     _CustomZone(parent, specification, map) {
@@ skipping 322 matching lines @@
     get createPeriodicTimer() {
       return _rootCreatePeriodicTimer;
     }
     get print() {
       return _rootPrint;
     }
     get fork() {
       return _rootFork;
     }
   }
+  _RootZoneSpecification[dart.implements] = [ZoneSpecification];
   let _rootMap = Symbol('_rootMap');
   let _rootDelegate = Symbol('_rootDelegate');
   class _RootZone extends _Zone {
     _RootZone() {
       super._Zone();
     }
     get [_run]() {
       return new _ZoneFunction(_ROOT_ZONE, _rootRun);
     }
     get [_runUnary]() {
@@ skipping 233 matching lines @@
   exports.StreamIterator = StreamIterator;
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));