anchor.diff:     *
      * The following text is non-normative:
      *
  -   * Specifying this option turns off the following warnings emitted by
  +   * Dart2js currently supports the following formats to specify symbols:
  +   *
  +   * * A constant [List] of [String] constants representing symbol names, 
  +   *   e.g., `const ['foo', 'bar']`.
  +   * * A single [String] constant whose value is a comma-separated list of
  +   *   symbol names, e.g., `"foo, bar"`.
  +   *
  +   * Specifying the `symbols` field turns off the following warnings emitted by
      * dart2js:
      *
      * * Using "MirrorSystem.getName" may result in larger output.
  -   * * Using "new #{name}" may result in larger output.
  -   *
  -   * Use symbols = "*" to turn off the warnings mentioned above.
  -   *
  -   * For example, if using [noSuchMethod] to interact with a database, extract
  -   * all the possible column names and include them in this list.  Similarly,
  -   * if using [noSuchMethod] to interact with another language (JavaScript, for
  -   * example) extract all the identifiers from API used and include them in
  -   * this list.
  +   * * Using "new Symbol" may result in larger output.
  +   *
  +   * For example, if you're using [noSuchMethod] to interact with a database,
  +   * extract all the possible column names and include them in this list.
  +   * Similarly, if you're using [noSuchMethod] to interact with another
  +   * language (JavaScript, for example) extract all the identifiers from the
  +   * API you use and include them in this list.
  +   *
  +   * Note that specifying a symbol only ensures that the symbol will be
  +   * available under that name at runtime. It does not mark targets with
  +   * that name as available for reflection. See [targets] and [metaTargets]
  +   * for that purpose.
      */
     final symbols;
   
  
positive.code:    *
     * 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});
  }
  
negative.code:  *       new Foo().foo(); // Prints "foo".
   *       new Foo().bar(); // Might print an arbitrary (mangled) name, "bar".
   *     }
   *
   * For a detailed description of the parameters to the [MirrorsUsed] constructor
   * see the comments for [symbols], [targets], [metaTargets] and [override].
   *
   * An import of `dart:mirrors` may have multiple [MirrorsUsed] annotations. This
   * is particularly helpful to specify overrides for specific libraries. For 
   * example:
   *
   *     @MirrorsUsed(targets: 'foo.Bar', override: 'foo')
   *     @MirrorsUsed(targets: 'Bar')
   *     import 'dart:mirrors';
   *
   * will ensure that the target `Bar` from the current library and from library
   * `foo` is available for reflection. See also [override].
   */
  class MirrorsUsed {
    // Note: the fields of this class are untyped.  This is because the most
    // convenient way to specify symbols today is using a single string. In 
    // some cases, a const list of classes might be convenient. Some
    // might prefer to use a const list of symbols.
  
    /**
  