dart:mirrors

lib/runtime/dart/_js_mirrors.js

Index: lib/runtime/dart/_js_mirrors.js
diff --git a/lib/runtime/dart/_js_mirrors.js b/lib/runtime/dart/_js_mirrors.js
new file mode 100644
index 0000000000000000000000000000000000000000..e4c1d24f2d6138716b6b269c0d052bab57f3a276
--- /dev/null
+++ b/lib/runtime/dart/_js_mirrors.js
@@ -0,0 +1,202 @@
+dart_library.library('dart/_js_mirrors', null, /* Imports */[
+  "dart_runtime/dart",
+  'dart/core',
+  'dart/mirrors'
+], /* Lazy imports */[
+], function(exports, dart, core, mirrors) {
+  'use strict';
+  let dartx = dart.dartx;
+  function getName(symbol) {
+    return symbol.toString().substring(8, symbol.toString().length - 2);
+  }
+  dart.fn(getName, core.String, [core.Symbol]);
+  function getSymbol(name, library) {
+    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 _instance = Symbol('_instance');
+  class JsInstanceMirror extends core.Object {
+    _(instance) {
+      this[_instance] = instance;
+    }
+    get reflectee() {
+      return this[_instance];
+    }
+    getField(symbol) {
+      let name = getName(symbol);
+      let field = _dload(this[_instance], name);
+      return new JsInstanceMirror._(field);
+    }
+    setField(symbol, value) {
+      let name = getName(symbol);
+      let field = _dput(this[_instance], name, value);
+      return new JsInstanceMirror._(field);
+    }
+    invoke(symbol, args, namedArgs) {
+      if (namedArgs === void 0)
+        namedArgs = null;
+      let name = getName(symbol);
+      let result = _dsend(this[_instance], name, args);
+      return new JsInstanceMirror._(result);
+    }
+  }
+  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)]]
+    })
+  });
+  let _simpleName = Symbol('_simpleName');
+  let _metadata = Symbol('_metadata');
+  let _declarations = Symbol('_declarations');
+  let _cls = Symbol('_cls');
+  class JsClassMirror extends core.Object {
+    get simpleName() {
+      return this[_simpleName];
+    }
+    get metadata() {
+      return this[_metadata];
+    }
+    get declarations() {
+      return this[_declarations];
+    }
+    _(cls) {
+      this[_cls] = cls;
+      this[_simpleName] = null;
+      this[_metadata] = null;
+      this[_declarations] = null;
+      this[_simpleName] = core.Symbol.new(this[_cls].name);
+      let fn = this[_cls][dart.metadata];
+      this[_metadata] = fn == null ? dart.list([], mirrors.InstanceMirror) : dart.as(dart.dsend(dart.dcall(fn), 'map', dart.fn(i => new JsInstanceMirror._(i), JsInstanceMirror, [core.Object])), core.List$(mirrors.InstanceMirror));
+      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;
+});