Support typeArguments, isOriginalDeclaration, and get originalDeclaration in ClassMirror.

sdk/lib/_internal/lib/js_mirrors.dart

 // Copyright (c) 2013, 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:async';
 import 'dart:collection' show UnmodifiableListView;
 import 'dart:mirrors';
 
@@ skipping 400 matching lines @@
 
 InstanceMirror reflect(Object reflectee) {
   if (reflectee is Closure) {
     return new JsClosureMirror(reflectee);
   } else {
     return new JsInstanceMirror(reflectee);
   }
 }
 
 ClassMirror reflectType(Type key) {
-  // TODO(ahe): Don't discard type arguments to support
-  // [ClassMirror.isOriginalDeclaration] and [ClassMirror.originalDeclaration]
-  // correctly.
-  return reflectClassByMangledName(getMangledTypeName(key).split('<')[0]);
+  return reflectClassByMangledName(getMangledTypeName(key));
 }
 
 ClassMirror reflectClassByMangledName(String mangledName) {
   String unmangledName = mangledGlobalNames[mangledName];
   if (unmangledName == null) unmangledName = mangledName;
   return reflectClassByName(s(unmangledName), mangledName);
 }
 
 var classMirrors;
 
 ClassMirror reflectClassByName(Symbol symbol, String mangledName) {
   if (classMirrors == null) classMirrors = JsCache.allocate();
   var mirror = JsCache.fetch(classMirrors, mangledName);
   if (mirror != null) return mirror;
   disableTreeShaking();
+  int typeArgIndex = mangledName.indexOf("<");
+  if (typeArgIndex != -1) {
+    mirror = new JsTypeBoundClassMirror(
+        reflectClassByMangledName(mangledName.substring(0, typeArgIndex)),
+        // Remove the angle brackets enclosing the type arguments.
+        mangledName.substring(typeArgIndex + 1, mangledName.length - 1));
+    JsCache.update(classMirrors, mangledName, mirror);
+    return mirror;
+  }
   var constructorOrInterceptor =
       Primitives.getConstructorOrInterceptor(mangledName);
   if (constructorOrInterceptor == null) {
     int index = JS('int|Null', 'init.functionAliases[#]', mangledName);
     if (index != null) {
       mirror = new JsTypedefMirror(
           symbol, mangledName, JS('=Object', 'init.metadata[#]', index));
       JsCache.update(classMirrors, mangledName, mirror);
       return mirror;
     }
@@ skipping 124 matching lines @@
       [Map<Symbol, dynamic> namedArguments]) {
     return new Future<InstanceMirror>(
         () => this.newInstance(
             constructorName, positionalArguments, namedArguments));
   }
 
   bool get isOriginalDeclaration => true;
 
   ClassMirror get originalDeclaration => this;
 
-  // TODO(ahe): Implement these.
-  Map<Symbol, TypeVariableMirror> get typeVariables {
+  // TODO(ahe): Implement this.
+  List<TypeVariableMirror> get typeVariables {
     throw new UnimplementedError();
   }
-  Map<Symbol, TypeMirror> get typeArguments => throw new UnimplementedError();
+
+  List<TypeMirror> get typeArguments => new List();
 }
 
 abstract class JsObjectMirror implements ObjectMirror {
   Future<InstanceMirror> setFieldAsync(Symbol fieldName, Object value) {
     return new Future<InstanceMirror>(() => this.setField(fieldName, value));
   }
 
   Future<InstanceMirror> getFieldAsync(Symbol fieldName) {
     return new Future<InstanceMirror>(() => this.getField(fieldName));
   }
@@ skipping 103 matching lines @@
     return other is JsInstanceMirror &&
            identical(reflectee, other.reflectee);
   }
 
   int get hashCode {
     // If the reflectee is a built-in type, use the base-level hashCode to
     // preserve the illusion that, e.g. doubles, with the same value are
     // identical. Otherwise, use the primitive identity hash to maintain
     // correctness even if a user-defined hashCode returns different values for
     // successive invocations.
-    var h = ((JS('bool', 'typeof # != "object"', reflectee)) || 
+    var h = ((JS('bool', 'typeof # != "object"', reflectee)) ||
              (reflectee == null))
         ? reflectee.hashCode
         : Primitives.objectHashCode(reflectee);
     // Avoid hash collisions with the reflectee. This constant is in Smi range
     // and happens to be the inner padding from RFC 2104.
     return h ^ 0x36363636;
   }
 
   String toString() => 'InstanceMirror on ${Error.safeToString(reflectee)}';
 
   // TODO(ahe): Remove this method from the API.
   MirrorSystem get mirrors => currentJsMirrorSystem;
 }
 
+/**
+ * ClassMirror for generic classes where the type parameters are bound.
+ *
+ * [typeArguments] will return a list of the type arguments, in constrast
+ * to JsCLassMirror that returns an empty list since it represents original
+ * declarations and classes that are not generic.
+ */
+class JsTypeBoundClassMirror implements ClassMirror {
+  final JsClassMirror _class;
+
+  /**
+   * When instantiated this field will hold a string representing the list of
+   * type arguments for the class, i.e. what is inside the outermost angle
+   * brackets. Then, when get typeArguments is called the first time, the string
+   * is parsed into the actual list of TypeMirrors, and the field is overridden
+   * with this value.
+   */
+  var _typeArgs;
+
+  JsTypeBoundClassMirror(this._class, this._typeArgs);
+
+  List<TypeVariableMirror> get typeVariables => _class.typeVariables;
+
+  List<TypeMirror> get typeArguments {
+    if (_typeArgs is! String) return _typeArgs;
+    List result = new List();
+    if (_typeArgs.indexOf('<') == -1) {
+      for (String s in _typeArgs.split(',')) {
+        result.add(reflectClassByMangledName(s.trim()));
+      }
+    } else {
+      int level = 0;
+      StringBuffer currentTypeArg = new StringBuffer();
+
+      addCurrentTypeArg() {
+        var classMirror = reflectClassByMangledName(currentTypeArg.toString());
+        result.add(classMirror);
+        currentTypeArg.clear();
+      }
+
+      for (int i = 0; i < _typeArgs.length; i++) {
+        var character = _typeArgs[i];
+        if (character == ' ') {
+          continue;
+        } else if (character == '<') {
+          currentTypeArg.write(character);
+          level++;
+        } else if (character == '>') {
+          currentTypeArg.write(character);
+          level--;
+        } else if (character == ',') {
+          if (level > 0) {
+            currentTypeArg.write(character);
+          } else {
+            addCurrentTypeArg();
+          }
+        } else {
+          currentTypeArg.write(character);
+        }
+      }
+      addCurrentTypeArg();
+    }
+    return _typeArgs = new UnmodifiableListView(result);
+  }
+
+  Map<Symbol, MethodMirror> get constructors => _class.constructors;
+
+  Map<Symbol, MethodMirror> get methods => _class.methods;
+
+  Map<Symbol, MethodMirror> get getters => _class.getters;
+
+  Map<Symbol, MethodMirror> get setters => _class.setters;
+
+  Map<Symbol, VariableMirror> get variables => _class.variables;
+
+  Map<Symbol, Mirror> get members => _class.members;
+
+  InstanceMirror setField(Symbol fieldName, Object arg) {
+    return _class.setField(fieldName, arg);
+  }
+
+  InstanceMirror getField(Symbol fieldName) => _class.getField(fieldName);
+
+  InstanceMirror newInstance(Symbol constructorName,
+                             List positionalArguments,
+                             [Map<Symbol, dynamic> namedArguments]) {
+    return _class.newInstance(constructorName,
+                              positionalArguments,
+                              namedArguments);
+  }
+
+  Future<InstanceMirror> newInstanceAsync(
+      Symbol constructorName,
+      List positionalArguments,
+      [Map<Symbol, dynamic> namedArguments]) {
+    return _class.newInstanceAsync(constructorName,
+                                   positionalArguments,
+                                   namedArguments);
+  }
+
+  JsLibraryMirror get owner => _class.owner;
+
+  List<InstanceMirror> get metadata => _class.metadata;
+
+  ClassMirror get superclass => _class.superclass;
+
+  InstanceMirror invoke(Symbol memberName,
+                        List positionalArguments,
+                        [Map<Symbol,dynamic> namedArguments]) {
+    return _class.invoke(memberName, positionalArguments, namedArguments);
+  }
+
+  bool get isOriginalDeclaration => false;
+
+  ClassMirror get originalDeclaration => _class;
+
+  List<ClassMirror> get superinterfaces => _class.superinterfaces;
+
+  Future<InstanceMirror> getFieldAsync(Symbol fieldName) {
+    return _class.getFieldAsync(fieldName);
+  }
+
+  bool get hasReflectedType => _class.hasReflectedType;
+
+  Future<InstanceMirror> invokeAsync(Symbol memberName,
+                                     List positionalArguments,
+                                     [Map<Symbol, dynamic> namedArguments]) {
+    return _class.invokeAsync(memberName, positionalArguments, namedArguments);
+  }
+
+  bool get isPrivate => _class.isPrivate;
+
+  bool get isTopLevel => _class.isTopLevel;
+
+  SourceLocation get location => _class.location;
+
+  MirrorSystem get mirrors => _class.mirrors;
+
+  Symbol get qualifiedName => _class.qualifiedName;
+
+  Type get reflectedType => _class.reflectedType;
+
+  Future<InstanceMirror> setFieldAsync(Symbol fieldName, Object value) {
+    return _class.setFieldAsync(fieldName, value);
+  }
+
+  Symbol get simpleName => _class.simpleName;
+}
+
 class JsClassMirror extends JsTypeMirror with JsObjectMirror
     implements ClassMirror {
   final String _mangledName;
   final _jsConstructorOrInterceptor;
   final String _fieldsDescriptor;
   final List _fieldsMetadata;
   final _jsConstructorCache = JsCache.allocate();
   List _metadata;
   ClassMirror _superclass;
   List<JsMethodMirror> _cachedMethods;
@@ skipping 344 matching lines @@
         var type = JS('=Object', 'init.metadata[#]', i);
         return typeMirrorFromRuntimeTypeRepresentation(type);
       }
       result = interfaces.map(lookupType).toList();
     }
     return _cachedSuperinterfaces =
         new UnmodifiableListView<ClassMirror>(result);
   }
 
   // TODO(ahe): Implement these.
-  Map<Symbol, TypeVariableMirror> get typeVariables
+  List<TypeVariableMirror> get typeVariables
       => throw new UnimplementedError();
-  Map<Symbol, TypeMirror> get typeArguments => throw new UnimplementedError();
+  List<TypeMirror> get typeArguments => new List();
 }
 
 class JsVariableMirror extends JsDeclarationMirror implements VariableMirror {
   static final int REFLECTION_MARKER = 45;
 
   // TODO(ahe): The values in these fields are virtually untested.
   final String _jsName;
   final bool isFinal;
   final bool isStatic;
   final _metadataFunction;
@@ skipping 349 matching lines @@
   final String _mangledName;
   final JsFunctionTypeMirror referent;
 
   JsTypedefMirror(Symbol simpleName,  this._mangledName, _typeData)
       : referent = new JsFunctionTypeMirror(_typeData),
         super(simpleName);
 
   JsFunctionTypeMirror get value => referent;
 
   String get _prettyName => 'TypedefMirror';
+
+  // TODO(zarah): This method doesn't belong here, since TypedefMirror shouldn't
+  // be a subtype of ClassMirror.
+  ClassMirror get originalDeclaration => this;
 }
 
 class JsFunctionTypeMirror implements FunctionTypeMirror {
   final _typeData;
   String _cachedToString;
   TypeMirror _cachedReturnType;
   UnmodifiableListView<ParameterMirror> _cachedParameters;
 
   JsFunctionTypeMirror(this._typeData);
 
@@ skipping 211 matching lines @@
   void operator []=(K key, V value) => _throw();
 
   V putIfAbsent(K key, V ifAbsent()) { _throw(); }
 
   void addAll(Map<K, V> other) => _throw();
 
   V remove(K key) { _throw(); }
 
   void clear() => _throw();
 }