anchor.diff:    // /// reflected class.
     // DeclarationMirror instanceLookup(Symbol name);
   
  -   /**
  +  /**
      * Invokes the named constructor and returns a mirror on the result.
      *
  -   * Let *c* be the class reflected by this mirror
  -   * let *a1, ..., an* be the elements of [positionalArguments]
  +   * Let *c* be the class reflected by this mirror,
  +   * let *a1, ..., an* be the elements of [positionalArguments],
      * let *k1, ..., km* be the identifiers denoted by the elements of
  -   * [namedArguments.keys]
  +   * [namedArguments.keys],
      * and let *v1, ..., vm* be the elements of [namedArguments.values].
  -   * If [constructorName] was created from the empty string
  -   * Then this method will execute the instance creation expression
  -   * *new c(a1, ..., an, k1: v1, ..., km: vm)*
  -   * in a scope that has access to the private members
  -   * of *c*. Otherwise, let
  -   * *f* be the simple name of the constructor denoted by [constructorName]
  -   * Then this method will execute the instance creation expression
  -   *  *new c.f(a1, ..., an, k1: v1, ..., km: vm)*
  -   * in a scope that has access to the private members
  -   * of *c*.
  +   *
  +   * If [constructorName] was created from the empty string, then this method
  +   * will execute the instance creation expression
  +   * *new c(a1, ..., an, k1: v1, ..., km: vm)* in a scope that has access to
  +   * the private members of *c*.
  +   *
  +   * Otherwise, let *f* be the simple name of the constructor denoted by
  +   * [constructorName]. Then this method will execute the instance creation
  +   * expression *new c.f(a1, ..., an, k1: v1, ..., km: vm)* in a scope that has
  +   * access to the private members of *c*.
  +   *
      * In either case:
  -   * If the expression evaluates to a result *r*, this method returns
  -   * the result of calling [reflect](*r*).
  -   * If evaluating the expression causes a compilation error
  -   * the effect is the same as if a non-reflective compilation error
  -   * had been encountered.
  -   * If evaluating the expression throws an exception *e*
  -   * (that it does not catch)
  -   * this method throws *e*.
  +   *
  +   * * If the expression evaluates to a result *r*, this method returns the
  +   *   result of calling [reflect]\(*r*\).
  +   * * If evaluating the expression causes a compilation error, the effect is
  +   *   the same as if a non-reflective compilation error had been encountered.
  +   * * If evaluating the expression throws an exception *e* (that it does not
  +   *   catch), this method throws *e*.
      */
     InstanceMirror newInstance(Symbol constructorName,
                                List positionalArguments,
                                [Map<Symbol,dynamic> namedArguments]);
   
     /**
  -   * Returns [:true:] if this mirror is equal to [other].
  -   * Otherwise returns [:false:].
  +   * Whether this mirror is equal to [other].
      *
      * The equality holds if and only if
  -   * (1) [other] is a mirror of the same kind
  -   * and
  -   * (2) This mirror and [other] reflect the same class.
  -   *
  -   * Note that if the reflected class is an invocation of
  -   * a generic class,(2) implies that the reflected class
  -   * and [other] have equal type arguments.
  -   */
  -   bool operator == (other);
  +   *
  +   * 1. [other] is a mirror of the same kind, and
  +   * 2. This mirror and [other] reflect the same class.
  +   *
  +   * Note that if the reflected class is an invocation of a generic class, 2.
  +   * implies that the reflected class and [other] have equal type arguments.
  +   */
  +  bool operator == (other);
   
     /**
      * Returns whether the class denoted by the receiver is a subclass of the
  
positive.code: abstract class TypedefMirror implements TypeMirror {
    /**
     * The defining type for this typedef.
     * If the the type referred to by the reflectee is a function type 
     * *F*, the result will be [:FunctionTypeMirror:] reflecting *F*
     * which is abstract and has an abstract method [:call:] whose 
     * signature corresponds to *F*.
     *
     * For instance [:void f(int):] is the referent for [:typedef void f(int):].
     */
    FunctionTypeMirror get referent;
  
negative.code: 
  
    /**
     * Checks the subtype relationship, denoted by `<:` in the language
     * specification.
     *
     * This is the type relationship used in `is` test checks.
     */
    bool isSubtypeOf(TypeMirror other);
  
    /**
     * Checks the assignability relationship, denoted by `<=>` in the language
     * specification.
     *
     * This is the type relationship tested on assignment in checked mode.
     */
    bool isAssignableTo(TypeMirror other);
  }
  