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

pkg/serialization/lib/src/format.dart

 part of serialization;
 
 /**
  * An abstract class for serialization formats. Subclasses define how data
  * is read or written to a particular output mechanism.
  */
 abstract class Format {
   /**
    * Return true if this format stores primitives in their own area and uses
    * references to them (e.g. [SimpleFlatFormat]) and false if primitives
@@ skipping 64 matching lines @@
 }
 
 /**
  * A format for "normal" [json] representation of objects. It stores
  * the fields of the objects as nested maps, and doesn't allow cycles. This can
  * be useful in talking to existing APIs that expect [json] format data. The
  * output will be either a simple object (string, num, bool), a List, or a Map,
  * with nesting of those.
  * Note that since the classes of objects aren't normally stored, this isn't
  * enough information to read back the objects. However, if the
- * If the [storeRoundTripData] field of the format is set to true, then this
+ * If the [storeRoundTripInfo] field of the format is set to true, then this
  * will store the rule number along with the data, allowing reconstruction.
  */
 class SimpleJsonFormat extends Format {
 
   /**
    * Indicate if we should store rule numbers with map/list data so that we
    * will know how to reconstruct it with a read operation. If we don't, this
    * will be more compliant with things that expect known format JSON as input,
    * but we won't be able to read back the objects.
    */
@@ skipping 92 matching lines @@
     var actualData = reader.selfDescribing ? data[DATA] : data;
     reader.readRules(rules);
     var ruleData = new List.generate(reader.rules.length, (_) => []);
     var top = recursivelyFixUp(actualData, reader, ruleData);
     result["data"] = ruleData;
     result["roots"] = [top];
     return result;
   }
 
   /**
-   * Convert nested references in [data] into [Reference] objects.
+   * Convert nested references in [input] into [Reference] objects.
    */
   recursivelyFixUp(input, Reader r, List result) {
     var data = input;
     if (isPrimitive(data)) {
       result[r._primitiveRule().number].add(data);
       return data;
     }
     var ruleNumber;
     // If we've added the rule number on as the last item in a list we have
     // to get rid of it or it will be interpreted as extra data. For a map
@@ skipping 253 matching lines @@
       return new Reference(r, a, b);
     }
   }
 
   /** Return the next element from the input. */
   _next(Iterator input) {
     input.moveNext();
     return input.current;
   }
 }