Make TypedefMirror a direct descendant of TypeMirror.

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 267 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 = _Mirrors._reflectType(_computeType(reflectee));
+      _type = reflectType(_computeType(reflectee));
     }
     return _type;
   }
 
   // LocalInstanceMirrors always reflect local instances
   bool hasReflectee = true;
 
   get reflectee => _reflectee;
 
   delegate(Invocation invocation) {
@@ skipping 210 matching lines @@
   ClassMirror get defaultFactory => null;
 
   ClassMirror _trueSuperclassField;
   ClassMirror get _trueSuperclass {
     if (_trueSuperclassField == null) {
       Type supertype = _supertype(_reflectee);
       if (supertype == null) {
         // Object has no superclass.
         return null;
       }
-      _trueSuperclassField = _Mirrors._reflectType(supertype);
+      _trueSuperclassField = reflectType(supertype);
     }
     return _trueSuperclassField;
   }
   ClassMirror get superclass {
     return _isMixinTypedef ? _trueSuperclass._trueSuperclass : _trueSuperclass;
   }
 
   var _superinterfaces;
   List<ClassMirror> get superinterfaces {
     if (_superinterfaces == null) {
       _superinterfaces = _interfaces(_reflectee)
-          .map((i) => _Mirrors._reflectType(i)).toList(growable:false);
+          .map((i) => reflectType(i)).toList(growable:false);
     }
     return _superinterfaces;
   }
 
   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) 
       + ' 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;
         } else {
-          _mixin = _Mirrors._reflectType(mixinType);
+          _mixin = reflectType(mixinType);
         }
       }
     }
     return _mixin;
   }
 
   Map<Symbol, Mirror> _members;
 
   Map<Symbol, Mirror> get members {
     if (_members == null) {
@@ skipping 211 matching lines @@
     if (_callMethod == null) {
       _callMethod = this._FunctionTypeMirror_call_method(_reflectee);
     }
     return _callMethod;
   }
 
   TypeMirror _returnType = null;
   TypeMirror get returnType {
     if (_returnType == null) {
       _returnType =
-          _Mirrors._reflectType(_FunctionTypeMirror_return_type(_reflectee));
+          reflectType(_FunctionTypeMirror_return_type(_reflectee));
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _FunctionTypeMirror_parameters(_reflectee);
     }
     return _parameters;
@@ skipping 67 matching lines @@
 
   SourceLocation get location {
     throw new UnimplementedError(
         'TypeVariableMirror.location is not implemented');
   }
 
   TypeMirror _upperBound = null;
   TypeMirror get upperBound {
     if (_upperBound == null) {
       _upperBound =
-          _Mirrors._reflectType(_TypeVariableMirror_upper_bound(_reflectee));
+          reflectType(_TypeVariableMirror_upper_bound(_reflectee));
     }
     return _upperBound;
   }
 
   List<InstanceMirror> get metadata {
     throw new UnimplementedError(
         'TypeVariableMirror.metadata is not implemented');
   }
 
   bool get isOriginalDeclaration => true;
@@ skipping 84 matching lines @@
 
   Map<Symbol, Mirror> _members;
 
   Map<Symbol, Mirror> get members {
     if (_members == null) {
       _members = _makeMemberMap(_computeMembers(_reflectee));
     }
     return _members;
   }
 
+  Map<Symbol, ClassMirror> _types = null;
   Map<Symbol, ClassMirror> _classes = null;
   Map<Symbol, MethodMirror> _functions = null;
   Map<Symbol, MethodMirror> _getters = null;
   Map<Symbol, MethodMirror> _setters = null;
   Map<Symbol, VariableMirror> _variables = null;
 
+  Map<Symbol, TypeMirror> get types {
+    if (_types == null) {
+      _types = _filterMap(members,

[Michael Lippautz (Google), 2013/09/06 16:58:40]

weird alignment

+                            (key, value) => (value is TypeMirror));
+    }
+    return _types;
+  }
+
   Map<Symbol, ClassMirror> get classes {
     if (_classes == null) {
       _classes = _filterMap(members,
                             (key, value) => (value is ClassMirror));
     }
     return _classes;
   }
 
   Map<Symbol, MethodMirror> get functions {
     if (_functions == null) {
@@ skipping 107 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 =

[Michael Lippautz (Google), 2013/09/06 16:58:40]

fits on prev line?

-            _Mirrors._reflectType(_MethodMirror_return_type(_reflectee));
+            reflectType(_MethodMirror_return_type(_reflectee));
       }
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _MethodMirror_parameters(_reflectee);
     }
@@ skipping 77 matching lines @@
   }
 
   SourceLocation get location {
     throw new UnimplementedError(
         'VariableMirror.location is not implemented');
   }
 
   TypeMirror _type;
   TypeMirror get type {
     if (_type == null) {
-       _type = _Mirrors._reflectType(_VariableMirror_type(_reflectee));
+       _type = reflectType(_VariableMirror_type(_reflectee));
     }
     return _type;
   }
 
   final bool isStatic;
   final bool isFinal;
 
   String toString() => "VariableMirror on '${_n(simpleName)}'";
 
   static _VariableMirror_type(reflectee)
@@ skipping 38 matching lines @@
   bool get hasDefaultValue => _defaultValueReflectee != null;
 
   List<InstanceMirror> get metadata {
     if ( _unmirroredMetadata == null) return const [];
     return _unmirroredMetadata.map(reflect).toList(growable:false);
   }
 
   TypeMirror _type = null;
   TypeMirror get type {
     if (_type == null) {
       _type =

[Michael Lippautz (Google), 2013/09/06 16:58:40]

ditto

-          _Mirrors._reflectType(_ParameterMirror_type(_reflectee, _position));
+          reflectType(_ParameterMirror_type(_reflectee, _position));
     }
     return _type;
   }
 
   String toString() => "ParameterMirror on '${_n(simpleName)}'";
 
   static Type _ParameterMirror_type(_reflectee, _position)
       native "ParameterMirror_type";
 }
 
@@ skipping 72 matching lines @@
         ? 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");
-  static Expando<ClassMirror> _instanitationCache = new Expando("TypeMirror");
+  static Expando<TypeMirror> _instanitationCache = new Expando("TypeMirror");
 
   static ClassMirror reflectClass(Type key) {
     var classMirror = _declarationCache[key];
     if (classMirror == null) {
       classMirror = makeLocalClassMirror(key);
       _declarationCache[key] = classMirror;
       if (!classMirror._isGeneric) {
         _instanitationCache[key] = classMirror;
       }
     }
     return classMirror;
   }
 
-  static TypeMirror _reflectType(Type key) {
+  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;
   }
 }