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 289 matching lines @@
    * in the corresponding class, the result of the invocation is an instance
    * mirror on a closure corresponding to that method.
    *
    * The method returns a future *k*.
    * If the invocation returns a result *r*, *k* will be completed
    * with the result of calling [reflect](*r*).
    * If the invocation throws an exception *e* (that it does not catch)
    * then *k* is completed with a [MirrorError] wrapping *e*.
    */
   /* TODO(turnidge): Handle ambiguous names.*/
   Future<InstanceMirror> getFieldAsync(Symbol fieldName);

[gbracha, 2013/10/02 22:49:53]

Didn't we get rid of getFieldAsync?

[rmacnak, 2013/10/03 17:24:47]

In another CL awaiting review.

 
   /**
    * Invokes a setter and returns a mirror on the result. The setter
    * may be either the implicit setter for a non-final field or a
    * user-defined setter method.
    * The second argument must be an instance of [InstanceMirror], or of
    * a type that is serializable across isolates (currently [num],
    * [String], or [bool]).
    *
    * Let *o* be the object reflected by this mirror, let
@@ skipping 181 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;
+
+  /**
    * 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 212 matching lines @@
    * 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});
 }