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 251 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 205 matching lines @@
   ClassMirror _trueSuperclassField;
   ClassMirror get _trueSuperclass {
     if (_trueSuperclassField == null) {
       Type supertype = isOriginalDeclaration
           ? _supertype(_reflectedType)
           : _supertypeInstantiated(_reflectedType);
       if (supertype == null) {
         // Object has no superclass.
         return null;
       }
-      _trueSuperclassField = _Mirrors._reflectType(supertype);
+      _trueSuperclassField = reflectType(supertype);
       _trueSuperclassField._instantiator = _instantiator;
     }
     return _trueSuperclassField;
   }
   ClassMirror get superclass {
     return _isMixinTypedef ? _trueSuperclass._trueSuperclass : _trueSuperclass;
   }
 
   var _superinterfaces;
   List<ClassMirror> get superinterfaces {
     if (_superinterfaces == null) {
       _superinterfaces = isOriginalDeclaration
           ? _nativeInterfaces(_reflectedType)
           : _nativeInterfacesInstantiated(_reflectedType);
       _superinterfaces = _superinterfaces
-          .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 (_nativeMixin(klass._reflectedType) != 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) {
         Type mixinType = isOriginalDeclaration
             ? _nativeMixin(_trueSuperclass._reflectedType)
             : _nativeMixinInstantiated(_trueSuperclass._reflectedType, _instantiator);
-        _mixin = _Mirrors._reflectType(mixinType);
+        _mixin = reflectType(mixinType);
       } else {
         Type mixinType = isOriginalDeclaration
             ? _nativeMixin(_reflectedType)
             : _nativeMixinInstantiated(_reflectedType, _instantiator);
         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) {
       var whoseMembers = _isMixinTypedef ? _trueSuperclass : this;
@@ skipping 220 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 65 matching lines @@
   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 =
-          _Mirrors._reflectType(_TypeVariableMirror_upper_bound(_reflectee));
+      _upperBound = reflectType(_TypeVariableMirror_upper_bound(_reflectee));
     }
     return _upperBound;
   }
 
   bool get hasReflectedType => false;
   Type get reflectedType => throw new UnsupportedError() ;
 
   List<TypeVariableMirror> get typeVariables => new UnmodifiableListView<TypeVariableMirror>();
   List<TypeMirror> get typeArguments => new UnmodifiableListView<TypeMirror>();
 
@@ skipping 18 matching lines @@
   static Type _TypeVariableMirror_instantiate_from(reflectee, instantiator)
       native "TypeVariableMirror_instantiate_from";
 
   TypeMirror _instantiateInContextOf(declaration) {
     var instantiator = declaration;
     while (instantiator is MethodMirror) instantiator = instantiator.owner;
     if (instantiator is LibraryMirror) return this;
     if (instantiator is! ClassMirror) throw "UNREACHABLE";
     if (instantiator.isOriginalDeclaration) return this;
 
-    return _Mirrors._reflectType(
-        _TypeVariableMirror_instantiate_from(
-            _reflectee,
-            instantiator._reflectedType));
+    return reflectType(
+        _TypeVariableMirror_instantiate_from(_reflectee,
+                                             instantiator._reflectedType));
   }
 }
 
 
 class _LocalTypedefMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypedefMirror {
   _LocalTypedefMirrorImpl(reflectee,
                           String simpleName,
                           this._owner)
       : super(reflectee, _s(simpleName));
@@ skipping 66 matching lines @@
   final Uri uri;
 
   Map<Symbol, Mirror> _members;
   Map<Symbol, Mirror> get members {
     if (_members == null) {
       _members = _makeMemberMap(_computeMembers(_reflectee));
     }
     return _members;
   }
 
+  Map<Symbol, ClassMirror> _types;
+  Map<Symbol, TypeMirror> get types {
+    if (_types == null) {
+      _types = _filterMap(members, (key, value) => (value is TypeMirror));
+    }
+    return _types;
+  }
+
   Map<Symbol, ClassMirror> _classes;
   Map<Symbol, ClassMirror> get classes {
     if (_classes == null) {
       _classes = _filterMap(members,
                             (key, value) => (value is ClassMirror));
     }
     return _classes;
   }
 
   Map<Symbol, MethodMirror> _functions;
@@ skipping 106 matching lines @@
   SourceLocation get location {
     throw new UnimplementedError('MethodMirror.location is not implemented');
   }
 
   TypeMirror _returnType = null;
   TypeMirror get returnType {
     if (_returnType == null) {
       if (isConstructor) {
         _returnType = owner;
       } else {
-        _returnType =
-            _Mirrors._reflectType(_MethodMirror_return_type(_reflectee));
+        _returnType = reflectType(_MethodMirror_return_type(_reflectee));
       }
       _returnType = _returnType._instantiateInContextOf(owner);
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _MethodMirror_parameters(_reflectee);
@@ skipping 75 matching lines @@
 
   bool get isTopLevel => owner is LibraryMirror;
 
   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));
        _type = _type._instantiateInContextOf(owner);
     }
     return _type;
   }
 
   String toString() => "VariableMirror on '${MirrorSystem.getName(simpleName)}'";
 
   static _VariableMirror_type(reflectee)
       native "VariableMirror_type";
 }
@@ skipping 36 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 =
-          _Mirrors._reflectType(_ParameterMirror_type(_reflectee, _position));
+      _type = reflectType(_ParameterMirror_type(_reflectee, _position));
       _type = _type._instantiateInContextOf(owner);
     }
     return _type;
   }
 
   String toString() => "ParameterMirror on '${_n(simpleName)}'";
 
   static Type _ParameterMirror_type(_reflectee, _position)
       native "ParameterMirror_type";
 }
@@ skipping 70 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;
   }
 }