anchor.diff:    ClassMirror get type;
   
     /**
  -   * Does [reflectee] contain the instance reflected by this mirror?
  -   * This will always be true in the local case (reflecting instances
  -   * in the same isolate), but only true in the remote case if this
  -   * mirror reflects a simple value.
  +   * Whether [reflectee] will return the instance reflected by this mirror.
  +   *
  +   * This will always be true in the local case (reflecting instances in the
  +   * same isolate), but only true in the remote case if this mirror reflects a
  +   * simple value.
      *
      * A value is simple if one of the following holds:
  -   *  - the value is [:null:]
  -   *  - the value is of type [num]
  -   *  - the value is of type [bool]
  -   *  - the value is of type [String]
  +   *
  +   * * the value is [:null:]
  +   * * the value is of type [num]
  +   * * the value is of type [bool]
  +   * * the value is of type [String]
      */
     bool get hasReflectee;
   
  
positive.code: 
    /**
     * Executes the closure and returns a mirror on the result.
     * Let *f* be the closure 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]
     * and let *v1, ..., vm* be the elements of [namedArguments.values].
     * Then this method will perform the method invocation
     *  *f(a1, ..., an, k1: v1, ..., km: vm)*
     * If the invocation returns a result *r*, this method returns
     * the result of calling [reflect]\(*r*\).
     * If the invocation causes a compilation error
     * the effect is the same as if a non-reflective compilation error
     * had been encountered.
     * If the invocation throws an exception *e* (that it does not catch)
     * this method throws *e*.
     */
    InstanceMirror apply(List positionalArguments,
                         [Map<Symbol, dynamic> namedArguments]);
  
negative.code:   get reflectee;
  
    /**
     * 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. either
     *
     *    a. [hasReflectee] is true and so is
     *    [:identical(reflectee, other.reflectee):], or
     *
     *    b. the remote objects reflected by this mirror and by [other] are
     *    identical.
     */
    bool operator == (other);
  }
  