dart:mirrors

tool/input_sdk/private/js_mirrors.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file

[Jennifer Messerly, 2015/06/15 16:42:01]

2015?

[vsm, 2015/06/15 20:59:47]

Done.

 // 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.
 
 library dart._js_mirrors;
 
-getName(symbol) {
-  throw new UnimplementedError("MirrorSystem.getName unimplemented");
+import 'dart:collection';
+import 'dart:mirrors';
+import 'dart:_foreign_helper' show JS;
+
+// TODO(vsm): This a workaround for:
+// https://github.com/dart-lang/dev_compiler/issues/219
+import 'dart:js';
+
+String getName(Symbol symbol) {
+  return JS('String', '#.toString().substring(8, #.toString().length - 2)', symbol, symbol);

[Jennifer Messerly, 2015/06/15 16:42:02]

Not sure toString the best way to implement this? We could be able to get ahold
of our _name field:

    import 'dart:_internal' as _internal;

    String getName(Symbol symbol) => _internal.Symbol.getName(symbol);

(from input_sdk/lib/internal/symbol.dart)

[vsm, 2015/06/15 20:59:47]

Done - thanks!

 }
 
-getSymbol(name, library) {
+Symbol getSymbol(name, library) {
   throw new UnimplementedError("MirrorSystem.getSymbol unimplemented");
 }
 
 final currentJsMirrorSystem =
   throw new UnimplementedError(
       "MirrorSystem.currentJsMirrorSystem unimplemented");
 
 
-reflect(reflectee) {
-  throw new UnimplementedError("MirrorSystem.reflect unimplemented");
+InstanceMirror reflect(reflectee) {
+  return new JsInstanceMirror._(reflectee);

[Jennifer Messerly, 2015/06/15 16:42:02]

silly: could be => ?

[vsm, 2015/06/15 20:59:47]

Done.

 }
 
-reflectType(Type key) {
-  throw new UnimplementedError("MirrorSystem.reflectType unimplemented");
+TypeMirror reflectType(Type key) {
+  // FIXME(vsm): Might not be a class.

[Jennifer Messerly, 2015/06/15 16:42:02]

TODO? or did you mean to fix before landing?

[vsm, 2015/06/15 20:59:46]

I'll update the mirrors bug.

+  return new JsClassMirror._(key);
 }
+
+final dynamic _dart = JS('', 'dart'); 

[Jennifer Messerly, 2015/06/15 16:42:02]

Not sure this field is worth it? if we're hardcoding "dart" global, it can be
hard coded inside the the places it's used. The level of indirection doesn't do
anything right?

[vsm, 2015/06/15 20:59:47]

Leaf had been moving / hiding some of our runtime libs - so not sure we want to
keep this all in the global.dart namespace?

[Jennifer Messerly, 2015/06/15 21:40:16]

eventually, yeah, things will move ... but we'll have to search for all of the
"dart." in JS snippets anyway at that point :)

the right long term solution is probably along the lines of
https://github.com/dart-lang/dev_compiler/issues/220

Not a big deal tho.

+final _metadata = JS('', '#.metadata', _dart);
+
+dynamic _dload(obj, String name) {

[Jennifer Messerly, 2015/06/15 16:42:02]

btw, if we wanted to make these APIs available statically. We could add a
private library to libraries.dart, with type signatures, and then import it. And
maybe have the compiler skip actual codegen for that library, since it's hand
coded, but it would still be able to generate imports to it.

filed https://github.com/dart-lang/dev_compiler/issues/220

[vsm, 2015/06/15 20:59:47]

thanks for filing!

+  return JS('', '#.dload(#, #)', _dart, obj, name);
+}
+
+void _dput(obj, String name, val) {
+  JS('', '#.dput(#, #, #)', _dart, obj, name, val);
+}
+
+dynamic _dsend(obj, String name, List args) {
+  return JS('', '#.dsendArray(#, #, #)', _dart, obj, name, args);
+}
+
+class JsInstanceMirror implements InstanceMirror {
+  Object _instance;

[Jennifer Messerly, 2015/06/15 16:42:01]

final?

[vsm, 2015/06/15 20:59:46]

Done.

+
+  JsInstanceMirror._(this._instance);
+
+  Object get reflectee {

[Jennifer Messerly, 2015/06/15 16:42:02]

This could just make `reflectee` be the final field name, and skip `_instance` ?

[vsm, 2015/06/15 20:59:47]

Done.

+    return this._instance;
+  }
+
+  InstanceMirror getField(Symbol symbol) {
+    var name = getName(symbol);
+    var field = _dload(_instance, name);
+    return new JsInstanceMirror._(field);
+  }
+
+  InstanceMirror setField(Symbol symbol, Object value) {
+    var name = getName(symbol);
+    var field = _dput(_instance, name, value);
+    return new JsInstanceMirror._(field);
+  }
+
+  InstanceMirror invoke(Symbol symbol, List<dynamic> args, [Map<Symbol, dynamic> namedArgs]) {

[Jennifer Messerly, 2015/06/15 16:42:02]

long line

[vsm, 2015/06/15 20:59:47]

Done.

+    var name = getName(symbol);
+    var result = _dsend(_instance, name, args);

[Jennifer Messerly, 2015/06/15 16:42:01]

TODO: named args?

or maybe implement it:

    if (namedArgs != null) {
      args = new List.from(args)
      args.add(_toJsMap(namedArgs));
    }
    _dsend(...)

dynamic _toJsMap(Map<Symbol, dynamic> map) {
  var obj = JS('', '{}');
  map.forEach((Symbol key, value) {
    JS('', '#[#] = #', obj, getName(key), value);
  });
  return obj;
}

[vsm, 2015/06/15 20:59:47]

Code stolen!  :-)

+    return new JsInstanceMirror._(result);
+  }
+}
+
+class JsClassMirror implements ClassMirror {
+  final Type _cls;
+  Symbol _simpleName;

[Jennifer Messerly, 2015/06/15 16:42:02]

final Symbol simpleName?

and init like:

JsClassMirror._(Type cls) {
  : _cls = cls,
    simpleName = new Symbol(JS('String', '#.name', cls));

[vsm, 2015/06/15 20:59:47]

Done.

+
+  List<InstanceMirror> _metadata;

[Jennifer Messerly, 2015/06/15 16:42:01]

these could probably be final too, but would need a bit more restructuring :)

[vsm, 2015/06/15 20:59:47]

Yes, I also need to make this immutable (see comment below).

+  Map<Symbol, MethodMirror> _declarations;
+
+  Symbol get simpleName => _simpleName;
+
+  // These need to be immutable when escaping from this class.
+  List<InstanceMirror> get metadata => _metadata;
+  Map<Symbol, MethodMirror> get declarations => _declarations;
+
+  JsClassMirror._(this._cls) {
+    _simpleName = new Symbol(JS('String', '#.name', _cls));
+
+    // Load metadata.
+    var fn = JS('List<InstanceMirror>', '#[dart.metadata]', _cls);

[Jennifer Messerly, 2015/06/15 16:42:02]

fyi, I don't think we parse this. (but we should)

+    _metadata = (fn == null) ? [] : fn().map((i) => new JsInstanceMirror._(i));

[Jennifer Messerly, 2015/06/15 16:42:02]

this looks like it's assigning Iterable<InstanceMirror> to List<InstanceMirror>
?

[vsm, 2015/06/15 20:59:47]

Good catch! - this is the problem with just emitting type check warnings at
runtime - too easy to ignore.  :-/

+
+    // Load declarations.
+    // FIXME(vsm): This is only populating the default constructor right now.
+    _declarations = new Map<Symbol, MethodMirror>();
+    _declarations[_simpleName] = new JsMethodMirror._(this, _cls);
+  }
+
+  InstanceMirror newInstance(Symbol constructorName, List args, [Map<Symbol, dynamic> namedArgs]) {

[Jennifer Messerly, 2015/06/15 16:42:01]

long line

[vsm, 2015/06/15 20:59:47]

Done.

+    // FIXME(vsm): Support named constructors and named arguments.
+    assert(getName(constructorName) == "");
+    assert(namedArgs == null || namedArgs.isEmpty);
+    var instance = JS('', '#.instantiate(#, #)', _dart, _cls, args);
+    return new JsInstanceMirror._(instance);
+  }
+}
+
+class JsTypeMirror implements TypeMirror {
+  final Type reflectedType;
+
+  JsTypeMirror._(this.reflectedType);
+}
+
+class JsParameterMirror implements ParameterMirror {
+  final String _name;
+  final TypeMirror type;
+  final List<InstanceMirror> metadata = [];
+
+  JsParameterMirror._(this._name, Type t) : type = new JsTypeMirror._(t);
+} 
+
+class JsMethodMirror implements MethodMirror {
+  final String _name;
+  final dynamic _method;
+  List<ParameterMirror> _params;
+
+  JsMethodMirror._(JsClassMirror cls, this._method) : _name = getName(cls._simpleName) {

[Jennifer Messerly, 2015/06/15 16:42:01]

long line

[vsm, 2015/06/15 20:59:46]

Done.

+    var ftype = JS('', '#.classGetConstructorType(#)', _dart, cls._cls);
+    _params = _createParameterMirrorList(ftype);
+  }
+
+  // TODO(vsm): Support named constructors.
+  Symbol get constructorName => new Symbol('');
+  List<ParameterMirror> get parameters => _params;
+
+  List<ParameterMirror> _createParameterMirrorList(ftype) {
+    if (ftype == null) {
+      // TODO(vsm): No explicit constructor.  Verify this.
+      return [];
+    }
+
+    // TODO(vsm): Add named args.
+    List args = ftype.args;
+    List opts = ftype.optionals;
+    var params = new List<ParameterMirror>(args.length + opts.length);
+
+    for (var i = 0; i < args.length; ++i) {
+      var type = args[i];
+      // TODO(vsm): Recover the param name.
+      var param = new JsParameterMirror._('', type);
+      params[i] = param;
+    }
+
+    for (var i = 0; i < opts.length; ++i) {
+      var type = opts[i];
+      // TODO(vsm): Recover the param name.
+      var param = new JsParameterMirror._('', type);
+      params[i + args.length] = param;
+    }
+
+    return params;
+  }
+}