Heartbeat implementation of dart:mirrors.

runtime/lib/mirrors_impl.dart

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// VM-specific implementation of the dart:mirrors library.
+
+class _IsolateMirrorImpl implements IsolateMirror {
+  _IsolateMirrorImpl(this.port, this.debugName) {}
+
+  final SendPort port;
+  final String debugName;
+
+  static buildCommand(List command) {
+    command.add('isolateMirrorOf');
+  }
+
+  static buildResponse(Map response) native "IsolateMirrorImpl_buildResponse";
+
+  static processResponse(SendPort port, Map response) {
+    if (response['ok']) {
+      return new _IsolateMirrorImpl(port, response['debugName']);
+    }
+    return null;
+  }
+}
+
+class _Mirrors {
+  static Future<IsolateMirror> isolateMirrorOf(SendPort port) {
+    Completer<IsolateMirror> completer = new Completer<IsolateMirror>();
+    List command = new List();
+    _IsolateMirrorImpl.buildCommand(command);
+    call(port, command).receive((message, _) {
+        completer.complete(_IsolateMirrorImpl.processResponse(port, message));
+      });
+    return completer.future;
+  }
+
+  static void processCommand(message, replyTo) {

[siva, 2012/02/18 01:25:55]

What is our convention with respect to parameters in library code? Do we
normally specify types for them or leave them untyped. This file seems to do
both, sometimes there are types and in this case it is untyped.

[turnidge, 2012/03/07 20:00:14]

Don't know.  It seems like I should add types where I can, so I have.

[siva, 2012/03/08 22:24:02]

I think the convention agreed upon (though not strictly followed) was to fully
type all the interfaces but try and not specify types in the implementation
code.

+    Map response = new Map();
+    if (message[0] == 'isolateMirrorOf') {
+      _IsolateMirrorImpl.buildResponse(response);
+    } else {
+      response['ok'] = false;
+    }
+    replyTo.send(response);
+  }
+
+  static ReceivePort call(port, message) {
+    ReceivePort rp = new ReceivePort.singleShot();
+    if (!send(port, message, rp.toSendPort())) {
+      throw new Exception("Unable to send mirror request to port $port");
+    }
+    return rp;
+  }
+
+  static bool send(port, message, replyTo) native "Mirrors_send";
+}