Support typeVariables 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 160 matching lines @@
   }
 
   _invoke(List positionalArguments, Map<Symbol, dynamic> namedArguments) {
     throw new RuntimeError('Should not call _invoke');
   }
 
   // TODO(ahe): Implement this.
   SourceLocation get location => throw new UnimplementedError();
 }
 
+class JsTypeVariableMirror extends JsTypeMirror {
+  final TypeMirror upperBound;
+  final DeclarationMirror owner;
+
+  JsTypeVariableMirror(Symbol simpleName, this.upperBound, this.owner)
+      : super(simpleName);
+
+  bool operator ==(other) {
+    return (other is JsTypeVariableMirror &&
+        simpleName == other.simpleName &&
+        owner == other.owner);
+  }
+
+  String get _prettyName => 'TypeVariableMirror';
+}
+
 class JsTypeMirror extends JsDeclarationMirror implements TypeMirror {
   JsTypeMirror(Symbol simpleName)
       : super(simpleName);
 
   String get _prettyName => 'TypeMirror';
 
   DeclarationMirror get owner => null;
 
   // TODO(ahe): Doesn't match the specification, see http://dartbug.com/11569.
   bool get isTopLevel => true;
@@ skipping 701 matching lines @@
   List<JsMethodMirror> _cachedMethods;
   List<JsVariableMirror> _cachedFields;
   UnmodifiableMapView<Symbol, MethodMirror> _cachedConstructors;
   UnmodifiableMapView<Symbol, MethodMirror> _cachedMethodsMap;
   UnmodifiableMapView<Symbol, MethodMirror> _cachedGetters;
   UnmodifiableMapView<Symbol, MethodMirror> _cachedSetters;
   UnmodifiableMapView<Symbol, VariableMirror> _cachedVariables;
   UnmodifiableMapView<Symbol, Mirror> _cachedMembers;
   UnmodifiableListView<InstanceMirror> _cachedMetadata;
   UnmodifiableListView<ClassMirror> _cachedSuperinterfaces;
+  UnmodifiableListView<TypeVariableMirror> _cachedTypeVariables;
 
   // Set as side-effect of accessing JsLibraryMirror.classes.
   JsLibraryMirror _owner;
 
   JsClassMirror(Symbol simpleName,
                 this._mangledName,
                 this._jsConstructorOrInterceptor,
                 this._fieldsDescriptor,
                 this._fieldsMetadata)
       : super(simpleName);
@@ skipping 324 matching lines @@
       ClassMirror lookupType(int i) {
         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.
-  List<TypeVariableMirror> get typeVariables
-      => throw new UnimplementedError();
+  List<TypeVariableMirror> get typeVariables {
+   if (_cachedTypeVariables != null) return _cachedTypeVariables;
+   List result = new List();
+   List typeVars =
+        JS('JSExtendableArray|Null', '#.prototype["<>"]', _jsConstructor);
+    if (typeVars == null) return result;
+    for (int i = 0; i < typeVars.length; i += 2) {
+      TypeMirror upperBound =
+         typeMirrorFromRuntimeTypeRepresentation(JS('', 'init.metadata[#]',
+                                                    typeVars[i+1]));
+      var typeMirror =
+          new JsTypeVariableMirror(s(typeVars[i]), upperBound, this);
+      result.add(typeMirror);
+    }
+    return _cachedTypeVariables = new UnmodifiableListView(result);
+  }
+
   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;
@@ skipping 585 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();
 }