keep mixin and interface implementation info at runtime

lib/runtime/dart/_isolate_helper.js

 var _isolate_helper;
 (function(exports) {
   'use strict';
   // Function _serializeMessage: (dynamic) → dynamic
   function _serializeMessage(message) {
     return new _Serializer().serialize(message);
   }
   // Function _deserializeMessage: (dynamic) → dynamic
   function _deserializeMessage(message) {
     return new _Deserializer().deserialize(message);
@@ skipping 711 matching lines @@
         }
         this.doneHandlers = null;
       }
     }
     unregister(portId) {
       this.ports.remove(portId);
       this.weakPorts.remove(portId);
       this[_updateGlobalState]();
     }
   }
+  _IsolateContext[dart.implements] = [_foreign_helper.IsolateContext];
   let _runHelper = Symbol('_runHelper');
   class _EventLoop extends core.Object {
     _EventLoop() {
       this.events = new collection.Queue();
       this[_activeJsAsyncCount] = 0;
     }
     enqueue(isolate, fn, msg) {
       this.events.addLast(new _IsolateEvent(dart.as(isolate, _IsolateContext), dart.as(fn, core.Function), dart.as(msg, core.String)));
     }
     prequeue(event) {
@@ skipping 375 matching lines @@
   class _BaseSendPort extends core.Object {
     _BaseSendPort(isolateId$) {
       this[_isolateId] = isolateId$;
     }
     [_checkReplyTo](replyTo) {
       if (dart.notNull(replyTo !== null) && dart.notNull(!dart.is(replyTo, _NativeJsSendPort)) && dart.notNull(!dart.is(replyTo, _WorkerSendPort))) {
         throw new core.Exception("SendPort.send: Illegal replyTo port type");
       }
     }
   }
+  _BaseSendPort[dart.implements] = [isolate.SendPort];
   let _isClosed = Symbol('_isClosed');
   class _NativeJsSendPort extends _BaseSendPort {
     _NativeJsSendPort(receivePort$, isolateId) {
       this[_receivePort] = receivePort$;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let isolate = exports._globalState.isolates.get(this[_isolateId]);
       if (isolate === null)
         return;
@@ skipping 10 matching lines @@
         }
       }).bind(this), `receive ${message}`);
     }
     ['=='](other) {
       return dart.notNull(dart.is(other, _NativeJsSendPort)) && dart.notNull(dart.equals(this[_receivePort], dart.dload(other, '_receivePort')));
     }
     get hashCode() {
       return this[_receivePort][_id];
     }
   }
+  _NativeJsSendPort[dart.implements] = [isolate.SendPort];
   class _WorkerSendPort extends _BaseSendPort {
     _WorkerSendPort(workerId$, isolateId, receivePortId$) {
       this[_workerId] = workerId$;
       this[_receivePortId] = receivePortId$;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let workerMessage = _serializeMessage(dart.map({command: 'message', port: this, msg: message}));
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(workerMessage);
       } else {
         let manager = exports._globalState.managers.get(this[_workerId]);
         if (manager !== null) {
           manager.postMessage(workerMessage);
         }
       }
     }
     ['=='](other) {
       return dart.notNull(dart.is(other, _WorkerSendPort)) && this[_workerId] === dart.dload(other, '_workerId') && this[_isolateId] === dart.dload(other, '_isolateId') && this[_receivePortId] === dart.dload(other, '_receivePortId');
     }
     get hashCode() {
       return dart.notNull(this[_workerId]) << 16 ^ dart.notNull(this[_isolateId]) << 8 ^ dart.notNull(this[_receivePortId]);
     }
   }
+  _WorkerSendPort[dart.implements] = [isolate.SendPort];
   let _handler = Symbol('_handler');
   let _nextFreeId = Symbol('_nextFreeId');
   let _close = Symbol('_close');
   let _add = Symbol('_add');
   class RawReceivePortImpl extends core.Object {
     RawReceivePortImpl(handler) {
       this[_handler] = handler;
       this[_id] = ((x$) => RawReceivePortImpl[_nextFreeId] = dart.notNull(x$) + 1, x$)(RawReceivePortImpl[_nextFreeId]);
       this[_isClosed] = false;
       exports._globalState.currentContext.register(this[_id], this);
@@ skipping 25 matching lines @@
     }
     [_add](dataEvent) {
       if (this[_isClosed])
         return;
       dart.dinvokef(this[_handler], dataEvent);
     }
     get sendPort() {
       return new _NativeJsSendPort(this, exports._globalState.currentContext.id);
     }
   }
+  RawReceivePortImpl[dart.implements] = [isolate.RawReceivePort];
   dart.defineNamedConstructor(RawReceivePortImpl, 'weak');
   dart.defineNamedConstructor(RawReceivePortImpl, _controlPort);
   RawReceivePortImpl._nextFreeId = 1;
   let _rawPort = Symbol('_rawPort');
   let _controller = Symbol('_controller');
   class ReceivePortImpl extends async.Stream {
     ReceivePortImpl() {
       this.fromRawReceivePort(new RawReceivePortImpl(null));
     }
     weak() {
@@ skipping 13 matching lines @@
       return this[_controller].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
     }
     close() {
       this[_rawPort].close();
       this[_controller].close();
     }
     get sendPort() {
       return this[_rawPort].sendPort;
     }
   }
+  ReceivePortImpl[dart.implements] = [isolate.ReceivePort];
   dart.defineNamedConstructor(ReceivePortImpl, 'weak');
   dart.defineNamedConstructor(ReceivePortImpl, 'fromRawReceivePort');
   let _once = Symbol('_once');
   let _inEventLoop = Symbol('_inEventLoop');
   let _handle = Symbol('_handle');
   class TimerImpl extends core.Object {
     TimerImpl(milliseconds, callback) {
       this[_once] = true;
       this[_inEventLoop] = false;
       this[_handle] = null;
@@ skipping 48 matching lines @@
         }
         this[_handle] = null;
       } else {
         throw new core.UnsupportedError("Canceling a timer.");
       }
     }
     get isActive() {
       return this[_handle] !== null;
     }
   }
+  TimerImpl[dart.implements] = [async.Timer];
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   // Function hasTimer: () → bool
   function hasTimer() {
     _js_helper.requiresPreamble();
     return self.setTimeout !== null;
   }
   let _internal = Symbol('_internal');
   class CapabilityImpl extends core.Object {
     CapabilityImpl() {
       this[_internal](_js_helper.random64());
@@ skipping 14 matching lines @@
     }
     ['=='](other) {
       if (core.identical(other, this))
         return true;
       if (dart.is(other, CapabilityImpl)) {
         return core.identical(this[_id], other[_id]);
       }
       return false;
     }
   }
+  CapabilityImpl[dart.implements] = [isolate.Capability];
   dart.defineNamedConstructor(CapabilityImpl, _internal);
   // Exports:
   exports.enterJsAsync = enterJsAsync;
   exports.leaveJsAsync = leaveJsAsync;
   exports.isWorker = isWorker;
   exports.startRootIsolate = startRootIsolate;
   exports.IsolateNatives = IsolateNatives;
   exports.RawReceivePortImpl = RawReceivePortImpl;
   exports.ReceivePortImpl = ReceivePortImpl;
   exports.TimerImpl = TimerImpl;
   exports.hasTimer = hasTimer;
   exports.CapabilityImpl = CapabilityImpl;
 })(_isolate_helper || (_isolate_helper = {}));