API changes to make TypedefMirror a direct descendant of TypeMirror.

sdk/lib/mirrors/mirrors.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.
 
 // For the purposes of the mirrors library, we adopt a naming
 // convention with respect to getters and setters.  Specifically, for
 // some variable or field...
 //
 //   var myField;
 //
@@ skipping 117 matching lines @@
  * obtain  mirrors on objects of the current isolate.
  */
 external InstanceMirror reflect(Object reflectee);
 
 /**
  * Let *C* be the original class declaration of the class
  * represented by [key].
  * This function returns a [ClassMirror] reflecting *C*.
  *
  * If [key] is not an instance of [Type] then this function
- * throws an [ArgumentError]. If [key] is the Type dynamic,
- * throws an [ArgumentError] because dynamic is not a class.
+ * throws an [ArgumentError]. If [key] is the Type for dynamic
+ * or a function typedef, throws an [ArgumentError].
  *
  * Note that since one cannot obtain a [Type] object from
  * another isolate, this function can only be used to
  * obtain class mirrors on classes of the current isolate.
  */
 external ClassMirror reflectClass(Type key);
 
 /**
+ * This function returns a [TypeMirror] reflecting the type
+ * represented by [key].
+ *
+ * If [key] is not an instance of [Type] then this function
+ * throws an [ArgumentError].
+ *
+ * Note that since one cannot obtain a [Type] object from
+ * another isolate, this function can only be used to
+ * obtain type mirrors on types of the current isolate.
+ */
+external TypeMirror reflectType(Type key);
+
+/**
  * A [Mirror] reflects some Dart language entity.
  *
  * Every [Mirror] originates from some [MirrorSystem].
  */
 abstract class Mirror {
   /**
    * The [MirrorSystem] that contains this mirror.
    */
   MirrorSystem get mirrors;
 }
@@ skipping 465 matching lines @@
    */
   Map<Symbol, Mirror> get members;
 
   /**
    * An immutable map from names to mirrors for all class
    * declarations in this library.
    */
   Map<Symbol, ClassMirror> get classes;
 
   /**
+   * An immutable map from names to mirrors for all type
+   * declarations in this library.
+   */
+  Map<Symbol, TypeMirror> get types;

[ahe, 2013/09/05 20:48:26]

I assume this goes away again after the "mirrors overhaul" CL.

PS: This is where I got stuck the first time I looked at this CL ;-)

[rmacnak, 2013/09/05 22:43:29]

Right, this would be covered by LibraryMirror.declarations.

+
+  /**
    * An immutable map from names to mirrors for all function, getter,
    * and setter declarations in this library.
    */
   Map<Symbol, MethodMirror> get functions;
 
   /**
    * An immutable map from names to mirrors for all getter
    * declarations in this library.
    */
   Map<Symbol, MethodMirror> get getters;
@@ skipping 44 matching lines @@
 
   /**
    * If [:hasReflectedType:] returns true, returns the corresponding [Type].
    * Otherwise, an [UnsupportedError] is thrown.
    */
   Type get reflectedType;
 
   /**
    * A mirror on the superclass on the reflectee.
    *
-   * If this type is [:Object:] or a typedef, the superClass will be
-   * null.
+   * If this type is [:Object:], the superClass will be null.
    */
   ClassMirror get superclass;
 
   /**
    * A list of mirrors on the superinterfaces of the reflectee.
    */
   List<ClassMirror> get superinterfaces;
 
   /**
    * An immutable map from from names to mirrors for all members of
@@ skipping 171 matching lines @@
    * a generic class,(2) implies that the reflected class
    * and [other] have equal type arguments.
    */
    bool operator == (other);
 }
 
 /**
  * A [FunctionTypeMirror] represents the type of a function in the
  * Dart language.
  */
 abstract class FunctionTypeMirror implements ClassMirror {

[ahe, 2013/09/05 20:48:26]

This is still a bit weird I think.

   /**
    * Returns the return type of the reflectee.
    */
   TypeMirror get returnType;
 
   /**
    * Returns a list of the parameter types of the reflectee.
    */
   List<ParameterMirror> get parameters;
 
   /**
    * A mirror on the [:call:] method for the reflectee.
    */
   MethodMirror get callMethod;

[ahe, 2013/09/05 20:48:26]

This method makes little sense to me. Do you know what it is for?

[rmacnak, 2013/09/05 22:43:29]

The methods of closures are special. reflect(()=>null).type.methods[#call]
doesn't work. I think there are plans to specify that function application is
just sugar for invoking call, then this will be unnecessary.

 }
 
 /**
  * A [TypeVariableMirror] represents a type parameter of a generic
  * type.
  */
 abstract class TypeVariableMirror extends TypeMirror {
   /**
    * A mirror on the type that is the upper bound of this type variable.
    */
   TypeMirror get upperBound;
 
   /**
    * Returns [:true:] if this mirror is equal to [other].
    * Otherwise returns [:false:].
    *
    * The equality holds if and only if
    * (1) [other] is a mirror of the same kind
    * and
    * (2)  [:simpleName == other.simpleName:] and
    * [:owner == other.owner:].
    */
    bool operator == (other);
 }
 
 /**
  * A [TypedefMirror] represents a typedef in a Dart language program.
  */
-abstract class TypedefMirror implements ClassMirror {
+abstract class TypedefMirror implements TypeMirror {
   /**
    * The defining type for this typedef.
    *
-   * For instance [:void f(int):] is the value for [:typedef void f(int):].
+   * For instance [:void f(int):] is the referent for [:typedef void f(int):].
    */
-  TypeMirror get value;
+  TypeMirror get referent;
 }
 
 /**
  * A [MethodMirror] reflects a Dart language function, method,
  * constructor, getter, or setter.
  */
 abstract class MethodMirror implements DeclarationMirror {
   /**
    * A mirror on the return type for the reflectee.
    */
@@ skipping 373 matching lines @@
    *
    * When used as metadata on an import of "dart:mirrors", this metadata does
    * not apply to the library in which the annotation is used, but instead
    * applies to the other libraries (all libraries if "*" is used).
    */
   final override;
 
   const MirrorsUsed(
       {this.symbols, this.targets, this.metaTargets, this.override});
 }