dart:mirrors

This is a very bare bones version - just enough to get angular running. See #199 R=jmesserly@google.com Review URL: https://codereview.chromium.org/1186683005.
dart-lang · Jun 15, 2015 · d48b153 · d48b153
1 parent b769aa5
commit d48b153
Show file tree

Hide file tree

Showing 14 changed files with 1,857 additions and 81 deletions.
diff --git a/pkg/dev_compiler/lib/runtime/_operations.js b/pkg/dev_compiler/lib/runtime/_operations.js
@@ -8,12 +8,15 @@
 dart_library.library('dart_runtime/_operations', null, /* Imports */[
 ], /* Lazy Imports */[
  'dart/async',
+ 'dart/collection',
  'dart/core',
+ 'dart/_js_helper',
  'dart_runtime/_classes',
  'dart_runtime/_errors',
  'dart_runtime/_rtti',
  'dart_runtime/_types'
-], function(exports, async, core, classes, errors, rtti, types) {
+], function(exports, async, collection, core, _js_helper, classes, errors, rtti,
+ types) {
  'use strict';
 
  const getOwnNamesAndSymbols = dart_utils.getOwnNamesAndSymbols;
@@ -146,7 +149,6 @@ dart_library.library('dart_runtime/_operations', null, /* Imports */[
  }
  exports.dcall = dcall;
 
-
  /** Shared code for dsend, dindex, and dsetindex. */
  function callMethod(obj, name, args, displayName) {
  let symbol = _canonicalFieldName(obj, name, args, displayName);
@@ -160,6 +162,11 @@ dart_library.library('dart_runtime/_operations', null, /* Imports */[
  }
  exports.dsend = dsend;
 
+ function dsendArray(obj, method, args) {
+ return dsend(obj, method, ...args);
+ }
+ exports.dsendArray = dsendArray;
+
  function dindex(obj, index) {
  return callMethod(obj, 'get', [index], '[]');
  }

diff --git a/pkg/dev_compiler/lib/runtime/dart/_js_mirrors.js b/pkg/dev_compiler/lib/runtime/dart/_js_mirrors.js
@@ -0,0 +1,207 @@
+dart_library.library('dart/_js_mirrors', null, /* Imports */[
+ "dart_runtime/dart",
+ 'dart/_internal',
+ 'dart/core',
+ 'dart/mirrors'
+], /* Lazy imports */[
+], function(exports, dart, _internal, core, mirrors) {
+ 'use strict';
+ let dartx = dart.dartx;
+ function getName(symbol) {
+ return _internal.Symbol.getName(dart.as(symbol, _internal.Symbol));
+ }
+ dart.fn(getName, core.String, [core.Symbol]);
+ function getSymbol(name, library) {
+ return dart.throw_(new core.UnimplementedError("MirrorSystem.getSymbol unimplemented"));
+ }
+ dart.fn(getSymbol, core.Symbol, [core.Object, core.Object]);
+ dart.defineLazyProperties(exports, {
+ get currentJsMirrorSystem() {
+ return dart.throw_(new core.UnimplementedError("MirrorSystem.currentJsMirrorSystem unimplemented"));
+ }
+ });
+ function reflect(reflectee) {
+ return new JsInstanceMirror._(reflectee);
+ }
+ dart.fn(reflect, mirrors.InstanceMirror, [core.Object]);
+ function reflectType(key) {
+ return new JsClassMirror._(key);
+ }
+ dart.fn(reflectType, mirrors.TypeMirror, [core.Type]);
+ dart.defineLazyProperties(exports, {
+ get _dart() {
+ return dart;
+ },
+ get _metadata() {
+ return exports._dart.metadata;
+ }
+ });
+ function _dload(obj, name) {
+ return exports._dart.dload(obj, name);
+ }
+ dart.fn(_dload, core.Object, [core.Object, core.String]);
+ function _dput(obj, name, val) {
+ exports._dart.dput(obj, name, val);
+ }
+ dart.fn(_dput, dart.void, [core.Object, core.String, core.Object]);
+ function _dsend(obj, name, args) {
+ return exports._dart.dsendArray(obj, name, args);
+ }
+ dart.fn(_dsend, core.Object, [core.Object, core.String, core.List]);
+ let _toJsMap = Symbol('_toJsMap');
+ class JsInstanceMirror extends core.Object {
+ _(reflectee) {
+ this.reflectee = reflectee;
+ }
+ getField(symbol) {
+ let name = getName(symbol);
+ let field = _dload(this.reflectee, name);
+ return new JsInstanceMirror._(field);
+ }
+ setField(symbol, value) {
+ let name = getName(symbol);
+ let field = _dput(this.reflectee, name, value);
+ return new JsInstanceMirror._(field);
+ }
+ invoke(symbol, args, namedArgs) {
+ if (namedArgs === void 0)
+ namedArgs = null;
+ let name = getName(symbol);
+ if (namedArgs != null) {
+ args = core.List.from(args);
+ args[dartx.add](this[_toJsMap](namedArgs));
+ }
+ let result = _dsend(this.reflectee, name, args);
+ return new JsInstanceMirror._(result);
+ }
+ [_toJsMap](map) {
+ let obj = {};
+ map.forEach(dart.fn((key, value) => {
+ obj[getName(key)] = value;
+ }, core.Object, [core.Symbol, core.Object]));
+ return obj;
+ }
+ }
+ JsInstanceMirror[dart.implements] = () => [mirrors.InstanceMirror];
+ dart.defineNamedConstructor(JsInstanceMirror, '_');
+ dart.setSignature(JsInstanceMirror, {
+ constructors: () => ({_: [JsInstanceMirror, [core.Object]]}),
+ methods: () => ({
+ getField: [mirrors.InstanceMirror, [core.Symbol]],
+ setField: [mirrors.InstanceMirror, [core.Symbol, core.Object]],
+ invoke: [mirrors.InstanceMirror, [core.Symbol, core.List], [core.Map$(core.Symbol, core.Object)]],
+ [_toJsMap]: [core.Object, [core.Map$(core.Symbol, core.Object)]]
+ })
+ });
+ let _metadata = Symbol('_metadata');
+ let _declarations = Symbol('_declarations');
+ let _cls = Symbol('_cls');
+ class JsClassMirror extends core.Object {
+ get metadata() {
+ return this[_metadata];
+ }
+ get declarations() {
+ return this[_declarations];
+ }
+ _(cls) {
+ this[_cls] = cls;
+ this.simpleName = core.Symbol.new(cls.name);
+ this[_metadata] = null;
+ this[_declarations] = null;
+ let fn = this[_cls][dart.metadata];
+ this[_metadata] = fn == null ? dart.list([], mirrors.InstanceMirror) : core.List$(mirrors.InstanceMirror).from(dart.as(dart.dsend(dart.dcall(fn), 'map', dart.fn(i => new JsInstanceMirror._(i), JsInstanceMirror, [core.Object])), core.Iterable));
+ this[_declarations] = core.Map$(core.Symbol, mirrors.MethodMirror).new();
+ this[_declarations].set(this.simpleName, new JsMethodMirror._(this, this[_cls]));
+ }
+ newInstance(constructorName, args, namedArgs) {
+ if (namedArgs === void 0)
+ namedArgs = null;
+ dart.assert(getName(constructorName) == "");
+ dart.assert(namedArgs == null || dart.notNull(namedArgs.isEmpty));
+ let instance = exports._dart.instantiate(this[_cls], args);
+ return new JsInstanceMirror._(instance);
+ }
+ }
+ JsClassMirror[dart.implements] = () => [mirrors.ClassMirror];
+ dart.defineNamedConstructor(JsClassMirror, '_');
+ dart.setSignature(JsClassMirror, {
+ constructors: () => ({_: [JsClassMirror, [core.Type]]}),
+ methods: () => ({newInstance: [mirrors.InstanceMirror, [core.Symbol, core.List], [core.Map$(core.Symbol, core.Object)]]})
+ });
+ class JsTypeMirror extends core.Object {
+ _(reflectedType) {
+ this.reflectedType = reflectedType;
+ }
+ }
+ JsTypeMirror[dart.implements] = () => [mirrors.TypeMirror];
+ dart.defineNamedConstructor(JsTypeMirror, '_');
+ dart.setSignature(JsTypeMirror, {
+ constructors: () => ({_: [JsTypeMirror, [core.Type]]})
+ });
+ let _name = Symbol('_name');
+ class JsParameterMirror extends core.Object {
+ _(name, t) {
+ this.metadata = dart.list([], mirrors.InstanceMirror);
+ this[_name] = name;
+ this.type = new JsTypeMirror._(t);
+ }
+ }
+ JsParameterMirror[dart.implements] = () => [mirrors.ParameterMirror];
+ dart.defineNamedConstructor(JsParameterMirror, '_');
+ dart.setSignature(JsParameterMirror, {
+ constructors: () => ({_: [JsParameterMirror, [core.String, core.Type]]})
+ });
+ let _method = Symbol('_method');
+ let _params = Symbol('_params');
+ let _createParameterMirrorList = Symbol('_createParameterMirrorList');
+ class JsMethodMirror extends core.Object {
+ _(cls, method) {
+ this[_method] = method;
+ this[_name] = getName(cls.simpleName);
+ this[_params] = null;
+ let ftype = exports._dart.classGetConstructorType(cls[_cls]);
+ this[_params] = this[_createParameterMirrorList](ftype);
+ }
+ get constructorName() {
+ return core.Symbol.new('');
+ }
+ get parameters() {
+ return this[_params];
+ }
+ [_createParameterMirrorList](ftype) {
+ if (ftype == null) {
+ return dart.list([], mirrors.ParameterMirror);
+ }
+ let args = dart.as(dart.dload(ftype, 'args'), core.List);
+ let opts = dart.as(dart.dload(ftype, 'optionals'), core.List);
+ let params = core.List$(mirrors.ParameterMirror).new(dart.notNull(args[dartx.length]) + dart.notNull(opts[dartx.length]));
+ for (let i = 0; dart.notNull(i) < dart.notNull(args[dartx.length]); i = dart.notNull(i) + 1) {
+ let type = args[dartx.get](i);
+ let param = new JsParameterMirror._('', dart.as(type, core.Type));
+ params[dartx.set](i, param);
+ }
+ for (let i = 0; dart.notNull(i) < dart.notNull(opts[dartx.length]); i = dart.notNull(i) + 1) {
+ let type = opts[dartx.get](i);
+ let param = new JsParameterMirror._('', dart.as(type, core.Type));
+ params[dartx.set](dart.notNull(i) + dart.notNull(args[dartx.length]), param);
+ }
+ return params;
+ }
+ }
+ JsMethodMirror[dart.implements] = () => [mirrors.MethodMirror];
+ dart.defineNamedConstructor(JsMethodMirror, '_');
+ dart.setSignature(JsMethodMirror, {
+ constructors: () => ({_: [JsMethodMirror, [JsClassMirror, core.Object]]}),
+ methods: () => ({[_createParameterMirrorList]: [core.List$(mirrors.ParameterMirror), [core.Object]]})
+ });
+ // Exports:
+ exports.getName = getName;
+ exports.getSymbol = getSymbol;
+ exports.reflect = reflect;
+ exports.reflectType = reflectType;
+ exports.JsInstanceMirror = JsInstanceMirror;
+ exports.JsClassMirror = JsClassMirror;
+ exports.JsTypeMirror = JsTypeMirror;
+ exports.JsParameterMirror = JsParameterMirror;
+ exports.JsMethodMirror = JsMethodMirror;
+});
diff --git a/pkg/dev_compiler/lib/runtime/dart/mirrors.js b/pkg/dev_compiler/lib/runtime/dart/mirrors.js
@@ -0,0 +1,140 @@
+dart_library.library('dart/mirrors', null, /* Imports */[
+ "dart_runtime/dart",
+ 'dart/core'
+], /* Lazy imports */[
+ 'dart/_js_mirrors'
+], function(exports, dart, core, _js_mirrors) {
+ 'use strict';
+ let dartx = dart.dartx;
+ class MirrorSystem extends core.Object {
+ findLibrary(libraryName) {
+ return this.libraries.values[dartx.singleWhere](dart.fn(library => dart.equals(dart.dload(library, 'simpleName'), libraryName), core.bool, [core.Object]));
+ }
+ static getName(symbol) {
+ return _js_mirrors.getName(symbol);
+ }
+ static getSymbol(name, library) {
+ if (library === void 0)
+ library = null;
+ return _js_mirrors.getSymbol(name, library);
+ }
+ }
+ dart.setSignature(MirrorSystem, {
+ methods: () => ({findLibrary: [LibraryMirror, [core.Symbol]]}),
+ statics: () => ({
+ getName: [core.String, [core.Symbol]],
+ getSymbol: [core.Symbol, [core.String], [LibraryMirror]]
+ }),
+ names: ['getName', 'getSymbol']
+ });
+ function currentMirrorSystem() {
+ return dart.as(_js_mirrors.currentJsMirrorSystem, MirrorSystem);
+ }
+ dart.fn(currentMirrorSystem, MirrorSystem, []);
+ function reflect(reflectee) {
+ return _js_mirrors.reflect(reflectee);
+ }
+ dart.fn(reflect, () => dart.functionType(InstanceMirror, [core.Object]));
+ function reflectClass(key) {
+ if (!dart.is(key, core.Type) || dart.equals(key, core.Object)) {
+ throw new core.ArgumentError(`${key} does not denote a class`);
+ }
+ let tm = reflectType(key);
+ if (!dart.is(tm, ClassMirror)) {
+ throw new core.ArgumentError(`${key} does not denote a class`);
+ }
+ return dart.as(dart.as(tm, ClassMirror).originalDeclaration, ClassMirror);
+ }
+ dart.fn(reflectClass, () => dart.functionType(ClassMirror, [core.Type]));
+ function reflectType(key) {
+ if (dart.equals(key, core.Object)) {
+ return currentMirrorSystem().dynamicType;
+ }
+ return _js_mirrors.reflectType(key);
+ }
+ dart.fn(reflectType, () => dart.functionType(TypeMirror, [core.Type]));
+ class Mirror extends core.Object {}
+ class IsolateMirror extends core.Object {}
+ IsolateMirror[dart.implements] = () => [Mirror];
+ class DeclarationMirror extends core.Object {}
+ DeclarationMirror[dart.implements] = () => [Mirror];
+ class ObjectMirror extends core.Object {}
+ ObjectMirror[dart.implements] = () => [Mirror];
+ class InstanceMirror extends core.Object {}
+ InstanceMirror[dart.implements] = () => [ObjectMirror];
+ class ClosureMirror extends core.Object {}
+ ClosureMirror[dart.implements] = () => [InstanceMirror];
+ class LibraryMirror extends core.Object {}
+ LibraryMirror[dart.implements] = () => [DeclarationMirror, ObjectMirror];
+ class LibraryDependencyMirror extends core.Object {}
+ LibraryDependencyMirror[dart.implements] = () => [Mirror];
+ class CombinatorMirror extends core.Object {}
+ CombinatorMirror[dart.implements] = () => [Mirror];
+ class TypeMirror extends core.Object {}
+ TypeMirror[dart.implements] = () => [DeclarationMirror];
+ class ClassMirror extends core.Object {}
+ ClassMirror[dart.implements] = () => [TypeMirror, ObjectMirror];
+ class FunctionTypeMirror extends core.Object {}
+ FunctionTypeMirror[dart.implements] = () => [ClassMirror];
+ class TypeVariableMirror extends TypeMirror {}
+ class TypedefMirror extends core.Object {}
+ TypedefMirror[dart.implements] = () => [TypeMirror];
+ class MethodMirror extends core.Object {}
+ MethodMirror[dart.implements] = () => [DeclarationMirror];
+ class VariableMirror extends core.Object {}
+ VariableMirror[dart.implements] = () => [DeclarationMirror];
+ class ParameterMirror extends core.Object {}
+ ParameterMirror[dart.implements] = () => [VariableMirror];
+ class SourceLocation extends core.Object {}
+ class Comment extends core.Object {
+ Comment(text, trimmedText, isDocComment) {
+ this.text = text;
+ this.trimmedText = trimmedText;
+ this.isDocComment = isDocComment;
+ }
+ }
+ dart.setSignature(Comment, {
+ constructors: () => ({Comment: [Comment, [core.String, core.String, core.bool]]})
+ });
+ class MirrorsUsed extends core.Object {
+ MirrorsUsed(opts) {
+ let symbols = opts && 'symbols' in opts ? opts.symbols : null;
+ let targets = opts && 'targets' in opts ? opts.targets : null;
+ let metaTargets = opts && 'metaTargets' in opts ? opts.metaTargets : null;
+ let override = opts && 'override' in opts ? opts.override : null;
+ this.symbols = symbols;
+ this.targets = targets;
+ this.metaTargets = metaTargets;
+ this.override = override;
+ }
+ }
+ dart.setSignature(MirrorsUsed, {
+ constructors: () => ({MirrorsUsed: [MirrorsUsed, [], {symbols: core.Object, targets: core.Object, metaTargets: core.Object, override: core.Object}]})
+ });
+ // Exports:
+ exports.MirrorSystem = MirrorSystem;
+ exports.currentMirrorSystem = currentMirrorSystem;
+ exports.reflect = reflect;
+ exports.reflectClass = reflectClass;
+ exports.reflectType = reflectType;
+ exports.Mirror = Mirror;
+ exports.IsolateMirror = IsolateMirror;
+ exports.DeclarationMirror = DeclarationMirror;
+ exports.ObjectMirror = ObjectMirror;
+ exports.InstanceMirror = InstanceMirror;
+ exports.ClosureMirror = ClosureMirror;
+ exports.LibraryMirror = LibraryMirror;
+ exports.LibraryDependencyMirror = LibraryDependencyMirror;
+ exports.CombinatorMirror = CombinatorMirror;
+ exports.TypeMirror = TypeMirror;
+ exports.ClassMirror = ClassMirror;
+ exports.FunctionTypeMirror = FunctionTypeMirror;
+ exports.TypeVariableMirror = TypeVariableMirror;
+ exports.TypedefMirror = TypedefMirror;
+ exports.MethodMirror = MethodMirror;
+ exports.VariableMirror = VariableMirror;
+ exports.ParameterMirror = ParameterMirror;
+ exports.SourceLocation = SourceLocation;
+ exports.Comment = Comment;
+ exports.MirrorsUsed = MirrorsUsed;
+});