Reflection on generics.

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 233 matching lines @@
   // TODO(ahe): This is a hack, see delegate below.
   static Function _invokeOnClosure;
 
   _LocalInstanceMirrorImpl(reflectee) : super(reflectee);
 
   ClassMirror _type;
   ClassMirror get type {
     if (_type == null) {
       // Note it not safe to use reflectee.runtimeType because runtimeType may
       // be overridden.
-      _type = reflectClass(_computeType(reflectee));
+      _type = _Mirrors._reflectType(_computeType(reflectee));
     }
     return _type;
   }
 
   // LocalInstanceMirrors always reflect local instances
   bool hasReflectee = true;
 
   get reflectee => _reflectee;
 
   delegate(Invocation invocation) {
@@ skipping 88 matching lines @@
   static _apply(reflectee, positionalArguments)
       native 'ClosureMirror_apply';
 
   static _computeFunction(reflectee)
       native 'ClosureMirror_function';
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
-                        String simpleName)
+                        this._reflectedType,
+                        String simpleName,
+                        this._isGeneric)
       : this._simpleName = _s(simpleName),
         super(reflectee);
 
+  final Type _reflectedType;
+  final bool _isGeneric;
+
   Symbol _simpleName;
   Symbol get simpleName {
     // dynamic, void and the function types have their names set eagerly in the
     // constructor.
     if(_simpleName == null) {
       _simpleName = _s(_name(_reflectee));
     }
     return _simpleName;
   }
 
@@ skipping 117 matching lines @@
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
         mirror = new _LocalTypeVariableMirrorImpl(
             params[i + 1], params[i], this);
         _typeVariables[mirror.simpleName] = mirror;
       }
     }
     return _typeVariables;
   }
 
+  Map<Symbol, TypeMirror> _typeArguments = null;
   Map<Symbol, TypeMirror> get typeArguments {
-    throw new UnimplementedError(
-        'ClassMirror.typeArguments is not implemented');
+    if(_typeArguments == null) {
+      if(_reflectedType == null) {
+        _typeArguments = new LinkedHashMap<Symbol, TypeMirror>();
+      } else {
+        _typeArguments =
+            new LinkedHashMap<Symbol, TypeMirror>.fromIterables(typeVariables.keys,
+                                                                _computeTypeArguments(_reflectedType));
+      }
+    }
+    return _typeArguments;
   }
 
   bool get isOriginalDeclaration {
-    throw new UnimplementedError(
-        'ClassMirror.isOriginalDeclaration is not implemented');
+    return !_isGeneric || _reflectedType == null;
   }
 
-  ClassMirror get genericDeclaration {
-    throw new UnimplementedError(
-        'ClassMirror.originalDeclaration is not implemented');
+  ClassMirror get originalDeclaration {
+    if (isOriginalDeclaration) {
+      return this;
+    } else {
+      return reflectClass(_reflectedType);
+    }
   }
 
   String toString() {
     return "ClassMirror on '${_n(simpleName)}'";
   }
 
   InstanceMirror newInstance(Symbol constructorName,
                              List positionalArguments,
                              [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
@@ skipping 24 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 &&
+           (isOriginalDeclaration || 
+            this._reflectedType == other._reflectedType);
   }
 
   int get hashCode => simpleName.hashCode;
 
   static _name(reflectee)
       native "ClassMirror_name";
 
   static _library(reflectee)
       native "ClassMirror_library";
 
@@ skipping 16 matching lines @@
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'ClassMirror_invokeSetter';
 
   static _invokeConstructor(reflectee, constructorName, positionalArguments)
       native 'ClassMirror_invokeConstructor';
 
   static _ClassMirror_type_variables(reflectee)
       native "ClassMirror_type_variables";
+
+  static _computeTypeArguments(reflectee)
+      native "ClassMirror_type_arguments";
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
     implements FunctionTypeMirror {
-  _LocalFunctionTypeMirrorImpl(reflectee) : super(reflectee, null);
+  _LocalFunctionTypeMirrorImpl(reflectee, reflectedType)
+      : super(reflectee, reflectedType, null, false);
 
   // FunctionTypeMirrors have a simpleName generated from their signature.
   Symbol _simpleName = null;
   Symbol get simpleName {
     if (_simpleName == null) {
       _simpleName = _s(_makeSignatureString(returnType, parameters));
     }
     return _simpleName;
   }
 
   TypeMirror _returnType = null;
   TypeMirror get returnType {
     if (_returnType == null) {
-      _returnType = _FunctionTypeMirror_return_type(_reflectee);
+      _returnType =
+          _Mirrors._reflectType(_FunctionTypeMirror_return_type(_reflectee));
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _FunctionTypeMirror_parameters(_reflectee);
     }
     return _parameters;
   }
 
   Map<Symbol, Mirror> get members => new Map<Symbol,Mirror>();
   Map<Symbol, MethodMirror> get constructors => new Map<Symbol,MethodMirror>();
   final Map<Symbol, TypeVariableMirror> typeVariables = const {};
 
   String toString() => "FunctionTypeMirror on '${_n(simpleName)}'";
 
-  static TypeMirror _FunctionTypeMirror_return_type(reflectee)
+  static Type _FunctionTypeMirror_return_type(reflectee)
       native "FunctionTypeMirror_return_type";
 
   static List<ParameterMirror> _FunctionTypeMirror_parameters(reflectee)
       native "FunctionTypeMirror_parameters";
 }
 
 abstract class _LocalDeclarationMirrorImpl extends _LocalMirrorImpl
     implements DeclarationMirror {
   _LocalDeclarationMirrorImpl(this._reflectee, this.simpleName);
 
@@ skipping 26 matching lines @@
 class _LocalTypeVariableMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypeVariableMirror {
   _LocalTypeVariableMirrorImpl(reflectee,
                                String simpleName,
                                this._owner)
       : super(reflectee, _s(simpleName));
 
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
-      _owner = _LocalTypeVariableMirror_owner(_reflectee);
+      _owner = _TypeVariableMirror_owner(_reflectee);
     }
     return _owner;
   }
 
   bool get isPrivate => false;
 
   final bool isTopLevel = false;
 
   SourceLocation get location {
     throw new UnimplementedError(
         'TypeVariableMirror.location is not implemented');
   }
 
   TypeMirror _upperBound = null;
   TypeMirror get upperBound {
     if (_upperBound == null) {
-      _upperBound = _LocalTypeVariableMirror_upper_bound(_reflectee);
+      _upperBound =
+          _Mirrors._reflectType(_TypeVariableMirror_upper_bound(_reflectee));
     }
     return _upperBound;
   }
 
   List<InstanceMirror> get metadata {
     throw new UnimplementedError(
         'TypeVariableMirror.metadata is not implemented');
   }
 
+  bool get isOriginalDeclaration => true;
+  ClassMirror get originalDeclaration => this;
+
   String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
 
-  static DeclarationMirror _LocalTypeVariableMirror_owner(reflectee)
-      native "LocalTypeVariableMirror_owner";
+  static DeclarationMirror _TypeVariableMirror_owner(reflectee)
+      native "TypeVariableMirror_owner";
 
-  static TypeMirror _LocalTypeVariableMirror_upper_bound(reflectee)
-      native "LocalTypeVariableMirror_upper_bound";
+  static Type _TypeVariableMirror_upper_bound(reflectee)
+      native "TypeVariableMirror_upper_bound";
 }
 
 
 class _LocalTypedefMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypedefMirror {
   _LocalTypedefMirrorImpl(reflectee,
                           String simpleName,
                           this._owner)
       : super(reflectee, _s(simpleName));
 
+  // TODO(12282): Deal with generic typedefs.
+  bool get _isGeneric => false;
+
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
       _owner = _LocalClassMirrorImpl._library(_reflectee);
     }
     return _owner;
   }
 
   bool get isPrivate => false;
 
   final bool isTopLevel = true;
 
   SourceLocation get location {
     throw new UnimplementedError(
         'TypedefMirror.location is not implemented');
   }
 
   TypeMirror _referent = null;
   TypeMirror get referent {
     if (_referent == null) {
+      // TODO(12282): Deal with generic typedef.
       return new _LocalFunctionTypeMirrorImpl(
-          _TypedefMirror_referent(_reflectee));
+          _TypedefMirror_referent(_reflectee), null);
     }
     return _referent;
   }
 
   String toString() => "TypedefMirror on '${_n(simpleName)}'";
 
   static _TypedefMirror_referent(_reflectee)
       native "TypedefMirror_referent";
 }
 
@@ skipping 147 matching lines @@
     throw new UnimplementedError(
         'MethodMirror.location is not implemented');
   }
 
   TypeMirror _returnType = null;
   TypeMirror get returnType {
     if (_returnType == null) {
       if (isConstructor) {
         _returnType = owner;
       } else {
-        _returnType = _MethodMirror_return_type(_reflectee);
+        _returnType =
+            _Mirrors._reflectType(_MethodMirror_return_type(_reflectee));
       }
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _MethodMirror_parameters(_reflectee);
     }
@@ skipping 73 matching lines @@
   }
 
   SourceLocation get location {
     throw new UnimplementedError(
         'VariableMirror.location is not implemented');
   }
 
   TypeMirror _type;
   TypeMirror get type {
     if (_type == null) {
-       _type = _VariableMirror_type(_reflectee);
+       _type = _Mirrors._reflectType(_VariableMirror_type(_reflectee));
     }
     return _type;
   }
 
   final bool isStatic;
   final bool isFinal;
 
   String toString() => "VariableMirror on '${_n(simpleName)}'";
 
   static _VariableMirror_type(reflectee)
@@ skipping 23 matching lines @@
 
   // TODO(11418): Implement.
   List<InstanceMirror> get metadata {
     throw new UnimplementedError(
         'ParameterMirror.metadata is not implemented');
   }
 
   TypeMirror _type = null;
   TypeMirror get type {
     if (_type == null) {
-      _type = _ParameterMirror_type(_reflectee, _position);
+      _type =
+          _Mirrors._reflectType(_ParameterMirror_type(_reflectee, _position));
     }
     return _type;
   }
 
-  static TypeMirror _ParameterMirror_type(_reflectee, _position)
+  static Type _ParameterMirror_type(_reflectee, _position)
       native "ParameterMirror_type";
 }
 
 class _SpecialTypeMirrorImpl extends _LocalMirrorImpl
     implements TypeMirror, DeclarationMirror {
   _SpecialTypeMirrorImpl(String name) : simpleName = _s(name);
 
   final bool isPrivate = false;
   final bool isTopLevel = true;
 
@@ skipping 59 matching lines @@
     }
   }
 
   // Creates a new local mirror for some Object.
   static InstanceMirror reflect(Object reflectee) {
     return reflectee is Function 
         ? new _LocalClosureMirrorImpl(reflectee)
         : new _LocalInstanceMirrorImpl(reflectee);
   }
 
-  // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
+  static TypeMirror makeLocalTypeMirror(Type key)
+      native "Mirrors_makeLocalTypeMirror";
 
-  static Expando<ClassMirror> _classMirrorCache = new Expando("ClassMirror");
+  static Expando<ClassMirror> _declarationCache = new Expando("ClassMirror");
+  static Expando<ClassMirror> _instanitationCache = new Expando("TypeMirror");
+
   static ClassMirror reflectClass(Type key) {
-    var classMirror = _classMirrorCache[key];
+    var classMirror = _declarationCache[key];
     if (classMirror == null) {
       classMirror = makeLocalClassMirror(key);
-      _classMirrorCache[key] = classMirror;
+      _declarationCache[key] = classMirror;
+      if (!classMirror._isGeneric) {
+        _instanitationCache[key] = classMirror;
+      }
     }
     return classMirror;
   }
+
+  static TypeMirror _reflectType(Type key) {
+    var typeMirror = _instanitationCache[key];
+    if (typeMirror == null) {
+      typeMirror = makeLocalTypeMirror(key);
+      _instanitationCache[key] = typeMirror;
+      if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
+        _declarationCache[key] = typeMirror;
+      }
+    }
+    return typeMirror;
+  }
 }