Change return type of get typeVariables and typeArguments in ClassMirror.

runtime/lib/mirrors_impl.dart

 // Copyright (c) 2012, 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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 import "dart:collection";
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
@@ skipping 174 matching lines @@
     }
 
     return reflect(this._invoke(_reflectee,
                                 _n(memberName),
                                 arguments,
                                 names));
   }
 
   InstanceMirror getField(Symbol memberName) {
     return reflect(this._invokeGetter(_reflectee,
-                                      _n(memberName))); 
+                                      _n(memberName)));
   }
 
   InstanceMirror setField(Symbol memberName, Object value) {
     this._invokeSetter(_reflectee,
                        _n(memberName),
                        value);
     return reflect(value);
   }
 
   Future<InstanceMirror> invokeAsync(Symbol memberName,
                                      List positionalArguments,
                                      [Map<Symbol, dynamic> namedArguments]) {
     return new Future(() {
       return this.invoke(memberName,
                          _unwrapAsyncPositionals(positionalArguments),
                          _unwrapAsyncNamed(namedArguments));
     });
   }
 
   Future<InstanceMirror> getFieldAsync(Symbol memberName) {
    try {
       var result = this._invokeGetter(_reflectee,
                                       _n(memberName));
-      return new Future.value(reflect(result)); 
+      return new Future.value(reflect(result));
     } catch(e) {
       return new Future.error(e);
     }
   }
 
   Future<InstanceMirror> setFieldAsync(Symbol memberName, Object value) {
     try {
       var unwrappedValue;
       if(_isSimpleValue(value)) {
         unwrappedValue = value;
       } else if(value is InstanceMirror) {
         unwrappedValue = value._reflectee;
-      } else { 
+      } else {
         throw "setter argument ($value) must be"
               "a simple value or InstanceMirror";
       }
 
       this._invokeSetter(_reflectee,
                          _n(memberName),
                          unwrappedValue);
-      return new Future.value(reflect(unwrappedValue)); 
+      return new Future.value(reflect(unwrappedValue));
     } catch(e) {
       return new Future.error(e);
     }
   }
 
   static _validateArgument(int i, Object arg)
   {
     if (arg is Mirror) {
         if (arg is! InstanceMirror) {
           throw new MirrorException(
@@ skipping 27 matching lines @@
   bool hasReflectee = true;
 
   get reflectee => _reflectee;
 
   delegate(Invocation invocation) {
     if (_invokeOnClosure == null) {
       // TODO(ahe): This is a total hack.  We're using the mirror
       // system to access a private field in a different library.  For
       // some reason, that works.  On the other hand, calling a
       // private method does not work.
-      
+
       _LocalInstanceMirrorImpl mirror =
           reflect(invocation);
       _invokeOnClosure = reflectClass(invocation.runtimeType)
           .getField(const Symbol('_invokeOnClosure')).reflectee;
     }
     return _invokeOnClosure(reflectee, invocation);
   }
 
   String toString() => 'InstanceMirror on ${Error.safeToString(_reflectee)}';
 
@@ skipping 69 matching lines @@
     }
     return _function;
   }
 
   InstanceMirror apply(List<Object> positionalArguments,
                        [Map<Symbol, Object> namedArguments]) {
     // TODO(iposva): When closures get an ordinary call method, this can be
     // replaced with
     //   return this.invoke(#call, positionalArguments, namedArguments);
     // and the native ClosureMirror_apply can be removed.
-    
+
     int numPositionalArguments = positionalArguments.length + 1;  // Receiver.
     int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
     int numArguments = numPositionalArguments + numNamedArguments;
     List arguments = new List(numArguments);
     arguments[0] = _reflectee;  // Receiver.
     arguments.setRange(1, numPositionalArguments, positionalArguments);
     List names = new List(numNamedArguments);
     int argumentIndex = numPositionalArguments;
     int nameIndex = 0;
     if (numNamedArguments > 0) {
@@ skipping 119 matching lines @@
   }
 
   get _mixinApplicationName {
     var mixins = new List<ClassMirror>();
     var klass = this;
     while (_computeMixin(klass._reflectee) != null) {
       mixins.add(klass.mixin);
       klass = klass.superclass;
     }
     return _s(
-      _n(klass.qualifiedName) 
+      _n(klass.qualifiedName)
       + ' with '
       + mixins.reversed.map((m)=>_n(m.qualifiedName)).join(', '));
   }
- 
+
   var _mixin;
   ClassMirror get mixin {
     if (_mixin == null) {
       if (_isMixinTypedef) {
         _mixin = _trueSuperclass.mixin;
       } else {
         var mixinType = _computeMixin(_reflectee);
         if (mixinType == null) {
           // The reflectee is not a mixin application.
           _mixin = this;
@@ skipping 54 matching lines @@
     return _variables;
   }
 
   Map<Symbol, MethodMirror> _constructors;
   Map<Symbol, MethodMirror> get constructors {
     if (_constructors == null) {
       var constructorsList = _computeConstructors(_reflectee);
       var stringName = _n(simpleName);
       constructorsList.forEach((c) => c._patchConstructorName(stringName));
       _constructors = _makeMemberMap(constructorsList);
-    } 
-    return _constructors;  
+    }
+    return _constructors;
   }
 
-  Map<Symbol, TypeVariableMirror> _typeVariables = null;
-  Map<Symbol, TypeVariableMirror> get typeVariables {
+  List<TypeVariableMirror> _typeVariables = null;
+  List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       List params = _ClassMirror_type_variables(_reflectee);
-      _typeVariables = new LinkedHashMap<Symbol, TypeVariableMirror>();
+      _typeVariables = new List<TypeVariableMirror>();
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
         mirror = new _LocalTypeVariableMirrorImpl(
             params[i + 1], params[i], this);
-        _typeVariables[mirror.simpleName] = mirror;
+        _typeVariables.add(mirror);
       }
     }
     return _typeVariables;
   }
 
-  Map<Symbol, TypeMirror> _typeArguments = null;
-  Map<Symbol, TypeMirror> get typeArguments {
+  List<TypeMirror> _typeArguments = null;
+  List<TypeMirror> get typeArguments {
     if(_typeArguments == null) {
       if(_isGenericDeclaration) {
-        _typeArguments = new LinkedHashMap<Symbol, TypeMirror>();
+        _typeArguments = new List<TypeMirror>();
       } else {
         _typeArguments =
-            new LinkedHashMap<Symbol, TypeMirror>.fromIterables(
-                typeVariables.keys, _computeTypeArguments(_reflectedType));
+            new List<TypeMirror>.from(_computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   bool get isOriginalDeclaration => !_isGeneric || _isGenericDeclaration;
 
   ClassMirror get originalDeclaration {
     if (isOriginalDeclaration) {
       return this;
@@ skipping 63 matching lines @@
       native "ClassMirror_supertype";
 
   static _interfaces(reflectee)
       native "ClassMirror_interfaces";
 
   static _computeMixin(reflectee)
       native "ClassMirror_mixin";
 
   _computeMembers(reflectee)
       native "ClassMirror_members";
-  
+
   _computeConstructors(reflectee)
       native "ClassMirror_constructors";
 
   _invoke(reflectee, memberName, arguments, argumentNames)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
@@ skipping 81 matching lines @@
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
     return _metadata(_reflectee).map(reflect).toList(growable:false);
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
-           this._reflectee == other._reflectee; 
+           this._reflectee == other._reflectee;
   }
 
   int get hashCode => simpleName.hashCode;
 }
 
 class _LocalTypeVariableMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypeVariableMirror {
   _LocalTypeVariableMirrorImpl(reflectee,
                                String simpleName,
                                this._owner)
@@ skipping 160 matching lines @@
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
     return _metadata(_reflectee).map(reflect).toList(growable:false);
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
-           this._reflectee == other._reflectee; 
+           this._reflectee == other._reflectee;
   }
 
   int get hashCode => simpleName.hashCode;
 
   String toString() => "LibraryMirror on '${_n(simpleName)}'";
 
   _invoke(reflectee, memberName, arguments, argumentNames)
       native 'LibraryMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
@@ skipping 285 matching lines @@
       }
     } else {
       // Make a remote mirror system
       throw new UnimplementedError(
           'Remote mirror support is not implemented');
     }
   }
 
   // Creates a new local mirror for some Object.
   static InstanceMirror reflect(Object reflectee) {
-    return reflectee is Function 
+    return reflectee is Function
         ? new _LocalClosureMirrorImpl(reflectee)
         : new _LocalInstanceMirrorImpl(reflectee);
   }
 
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
   static TypeMirror makeLocalTypeMirror(Type key)
       native "Mirrors_makeLocalTypeMirror";
 
   static Expando<ClassMirror> _declarationCache = new Expando("ClassMirror");
@@ skipping 16 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }