Wrap and unwrap types in dart:mirrors

tool/input_sdk/private/js_mirrors.dart

 // Copyright (c) 2015, 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.
 
 library dart._js_mirrors;
 
 import 'dart:mirrors';
 import 'dart:_foreign_helper' show JS;
 import 'dart:_internal' as _internal;
 
@@ skipping 20 matching lines @@
 }
 
 void _dput(obj, String name, val) {
   JS('', '#.dput(#, #, #)', _dart, obj, name, val);
 }
 
 dynamic _dsend(obj, String name, List args) {
   return JS('', '#.dsend(#, #, ...#)', _dart, obj, name, args);
 }
 
+// TODO(vsm): These methods need to validate whether we really have a
+// WrappedType or a raw type that should be wrapped (as opposed to a
+// function).
+dynamic _unwrap(obj) => JS('', '#.unwrapped()', obj);
+
+dynamic _wrap(obj) => JS('', '#.wrapType(#)', _dart, obj);
+
 class JsInstanceMirror implements InstanceMirror {
   final Object reflectee;
 
   JsInstanceMirror._(this.reflectee);
 
   ClassMirror get type =>
       throw new UnimplementedError("ClassMirror.type unimplemented");
   bool get hasReflectee =>
       throw new UnimplementedError("ClassMirror.hasReflectee unimplemented");
   delegate(Invocation invocation) =>
@@ skipping 37 matching lines @@
 
   List<InstanceMirror> _metadata;
   Map<Symbol, MethodMirror> _declarations;
 
   // TODO(vsm):These need to be immutable when escaping from this class.
   List<InstanceMirror> get metadata => _metadata;
   Map<Symbol, MethodMirror> get declarations => _declarations;
 
   JsClassMirror._(Type cls)
       : _cls = cls,
-        simpleName = new Symbol(JS('String', '#.name', cls)) {
+        simpleName = new Symbol(JS('String', '#.name', _unwrap(cls))) {
     // Load metadata.
-    var fn = JS('Function', '#[dart.metadata]', _cls);
+    var fn = JS('Function', '#[dart.metadata]', _unwrap(_cls));
     _metadata = (fn == null)
         ? <InstanceMirror>[]
         : new List<InstanceMirror>.from(
             fn().map((i) => new JsInstanceMirror._(i)));
 
     // Load declarations.
     // TODO(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]) {
     // TODO(vsm): Support named constructors and named arguments.
     assert(getName(constructorName) == "");
     assert(namedArgs == null || namedArgs.isEmpty);
-    var instance = JS('', 'new #(...#)', _cls, args);
+    var instance = JS('', 'new #(...#)', _unwrap(_cls), args);
     return new JsInstanceMirror._(instance);
   }
 
   List<ClassMirror> get superinterfaces {
-    var interfaceThunk = JS('Function', '#[dart.implements]', _cls);
+    var interfaceThunk = JS('Function', '#[dart.implements]', _unwrap(_cls));
     if (interfaceThunk == null) {
       return [];
     } else {
       List<Type> interfaces = interfaceThunk();
       return interfaces.map((t) => new JsClassMirror._(t)).toList();
     }
   }
 
   // TODO(vsm): Implement
   InstanceMirror getField(Symbol fieldName) =>
@@ skipping 36 matching lines @@
       throw new UnimplementedError("ClassMirror.owner unimplemented");
   Symbol get qualifiedName =>
       throw new UnimplementedError("ClassMirror.qualifiedName unimplemented");
   Type get reflectedType { return _cls; }
   Map<Symbol, MethodMirror> get staticMembers =>
       throw new UnimplementedError("ClassMirror.staticMembers unimplemented");
   ClassMirror get superclass {
     if (_cls == Object) {
       return null;
     } else {
-      return new JsClassMirror._(JS('Type', '#.__proto__', _cls));
+      return new JsClassMirror._(_wrap(JS('Type', '#.__proto__', _unwrap(_cls))));
     }
   }
   List<TypeMirror> get typeArguments =>
       throw new UnimplementedError("ClassMirror.typeArguments unimplemented");
   List<TypeVariableMirror> get typeVariables =>
       throw new UnimplementedError("ClassMirror.typeVariables unimplemented");
 }
 
 class JsTypeMirror implements TypeMirror {
   // TODO(vsm): Support original declarations, etc., where there is no actual
@@ skipping 71 matching lines @@
       throw new UnimplementedError("ParameterMirror.simpleName unimplemented");
 }
 
 class JsMethodMirror implements MethodMirror {
   final String _name;
   final dynamic _method;
   List<ParameterMirror> _params;
 
   JsMethodMirror._(JsClassMirror cls, this._method)
       : _name = getName(cls.simpleName) {
-    var ftype = JS('', '#.classGetConstructorType(#)', _dart, cls._cls);
+    var ftype = JS('', '#.classGetConstructorType(#)', _dart, _unwrap(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];
       var metadata = ftype.metadata[i];
       // TODO(vsm): Recover the param name.
-      var param = new JsParameterMirror._('', type, metadata);
+      var param = new JsParameterMirror._('', _wrap(type), metadata);
       params[i] = param;
     }
 
     for (var i = 0; i < opts.length; ++i) {
       var type = opts[i];
       var metadata = ftype.metadata[args.length + i];
       // TODO(vsm): Recover the param name.
-      var param = new JsParameterMirror._('', type, metadata);
+      var param = new JsParameterMirror._('', _wrap(type), metadata);
       params[i + args.length] = param;
     }
 
     return params;
   }
 
   // TODO(vsm): Implement
   bool get isAbstract =>
       throw new UnimplementedError("MethodMirror.isAbstract unimplemented");
   bool get isConstConstructor => throw new UnimplementedError(
@@ skipping 32 matching lines @@
       throw new UnimplementedError("MethodMirror.owner unimplemented");
   Symbol get qualifiedName =>
       throw new UnimplementedError("MethodMirror.qualifiedName unimplemented");
   TypeMirror get returnType =>
       throw new UnimplementedError("MethodMirror.returnType unimplemented");
   Symbol get simpleName =>
       throw new UnimplementedError("MethodMirror.simpleName unimplemented");
   String get source =>
       throw new UnimplementedError("MethodMirror.source unimplemented");
 }