Fix for mirror API breaking change to index libraries by URI, and clean up references in doc commen…

pkg/serialization/lib/src/reader_writer.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.
 
 part of serialization;
 
 /**
  * This writes out the state of the objects to an external format. It holds
  * all of the intermediate state needed. The primary API for it is the
  * [write] method.
@@ skipping 193 matching lines @@
    * no reference, return the object itself. Once we have finished the tracing
    * step, all objects that should have a reference (roughly speaking,
    * non-primitives) can be relied on to have a reference.
    */
   _referenceFor(object) {
     var result = references[object];
     return (result == null) ? object : result;
   }
 
   /**
-   * Return true if the [namedObjects] collection has a reference to [object].
+   * Return true if the [Serialization.namedObjects] collection has a
+   * reference to [object].
    */
   // TODO(alanknight): Should the writer also have its own namedObjects
   // collection specific to the particular write, or is that just adding
   // complexity for little value?
   hasNameFor(object) => serialization._hasNameFor(object);
 
   /**
-   * Return the name we have for this object in the [namedObjects] collection.
+   * Return the name we have for this object in the [Serialization.namedObjects]
+   * collection.
    */
   nameFor(object) => serialization._nameFor(object);
 
   // For debugging/testing purposes. Find what state a reference points to.
   stateForReference(Reference r) => states[r.ruleNumber][r.objectNumber];
 
   /** Return the state pointed to by [reference]. */
   resolveReference(reference) => stateForReference(reference);
 }
 
@@ skipping 38 matching lines @@
    * Each rule has a number, and rules keep track of the objects that they
    * serialize, in order. So the state of any object can be found by indexing
    * from the rule number and the object number within the rule.
    * The actual representation of the state is determined by the rule. Lists
    * and Maps are common, but it is arbitrary. See [Writer.states].
    */
   List<List> _data;
 
   /**
    * The resulting objects, indexed according to the same scheme as
-   * [data], where each rule has a number, and rules keep track of the objects
+   * _data, where each rule has a number, and rules keep track of the objects
    * that they serialize, in order.
    */
   List<List> objects;
 
   Format format = new SimpleMapFormat();
 
   /**
    * Creates a new [Reader] that uses the rules from its parent
    * [Serialization]. Serializations do not keep any state related to
    * a particular read or write operation, so the same one can be used
@@ skipping 280 matching lines @@
   /**
    * Return the thing this reference points to. Assumes that we have a valid
    * parent and that it is a Reader, as inflating is not meaningful when
    * writing.
    */
   inflated() => parent.resolveReference(this);
 
   /**
    * Convert the reference to a map in JSON format. This is specific to the
    * custom JSON format we define, and must be consistent with the
-   * [asReference] method.
+   * [Reader.asReference] method.
    */
   // TODO(alanknight): This is a hack both in defining a toJson specific to a
   // particular representation, and the use of a bogus sentinel "__Ref"
   toJson() => {
     "__Ref" : true,
     "rule" : ruleNumber,
     "object" : objectNumber
   };
 
   /** Write our information to [list]. Useful in writing to flat formats.*/
@@ skipping 13 matching lines @@
  * for an example. It knows how to return its object and how to filter.
  */
 class DesignatedRuleForObject {
   Function rulePredicate;
   final target;
 
   DesignatedRuleForObject(this.target, this.rulePredicate);
 
   possibleRules(List rules) => rules.where(rulePredicate).toList();
 }