Big merge from experimental to bleeding edge.

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 208 matching lines @@
   int _objectNumberFor(object) {
     var reference = references[object];
     return (reference == null) ? -1 : reference.objectNumber;
   }
 
   /**
    * Return the serialized data in string format. Currently hard-coded to
    * our custom JSON format.
    */
   String toStringFormat() {
-    return JSON.stringify(toMaps());
+    return json.stringify(toMaps());
   }
 
   /**
    * Returns the full serialized structure as nested maps. The top-level
    * has 3 fields, "rules" which may hold a definition of the rules used,
    * "data" which holds the serialized data, and "roots", which holds
    * [Reference] objects indicating the root objects. Note that roots are
    * necessary because the data is organized in the same way as the object
    * structure, it's a list of lists holding self-contained maps which only
    * refer to other parts via [Reference] objects.
@@ skipping 13 matching lines @@
     result["data"] = states;
     result["roots"] = _rootReferences(trace.roots);
     return result;
   }
 
   /**
    * Return a list of [Reference] objects pointing to our roots. This will be
    * stored in the output under "roots" in the default format.
    */
   _rootReferences(roots) =>
-    roots.map(_referenceFor);
+    roots.mappedBy(_referenceFor).toList();
 
   /**
    * Given an object, return a reference for it if one exists. If there's
    * no reference, return null. 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) => references[object];
 
   /**
@@ skipping 88 matching lines @@
    */
   List<SerializationRule> get rules => serialization._rules;
 
   /**
    * Internal use only, for testing purposes. Set the data for this reader
    * to a List of Lists whose size must match the number of rules.
    */
   // When we set the data, initialize the object storage to a matching size.
   void set data(List<List> newData) {
     _data = newData;
-    objects = _data.map((x) => new List(x.length));
+    objects = _data.mappedBy((x) => new List(x.length)).toList();
   }
 
   /**
    * This is the primary method for a [Reader]. It takes the input data,
    * currently hard-coded to expect our custom JSON format, and returns
    * the root object.
    */
   read(String input, [Map externals = const {}]) {
     namedObjects = externals;
-    var topLevel = JSON.parse(input);
+    var topLevel = json.parse(input);
     var ruleString = topLevel["rules"];
     readRules(ruleString, externals);
     data = topLevel["data"];
     rules.forEach(inflateForRule);
     var roots = topLevel["roots"];
     return inflateReference(roots.first);
   }
 
   /**
    * If the data we are reading from has rules written to it, read them back
@@ skipping 15 matching lines @@
    * of fixing and generalization.
    */
   readFlat(List input, [Map externals = const {}]) {
     // TODO(alanknight): Way too much code duplication with read. Numerous
     // code smells.
     namedObjects = externals;
     var topLevel = input;
     var ruleString = topLevel[0];
     readRules(ruleString, externals);
     var flatData = topLevel[1];
-    var stream = flatData.iterator();
+    var stream = flatData.iterator;
     var tempData = new List(rules.length);
      for (var eachRule in rules) {
        tempData[eachRule.number] = eachRule.pullStateFrom(stream);
     }
     data = tempData;
     for (var eachRule in rules) {
       inflateForRule(eachRule);
     }
     var rootsAsInts = topLevel[2];
-    var rootStream = rootsAsInts.iterator();
+    var rootStream = rootsAsInts.iterator;
     var roots = new List();
-    while (rootStream.hasNext) {
-      roots.add(new Reference(this, rootStream.next(), rootStream.next()));
+    while (rootStream.moveNext()) {
+      var first = rootStream.current;
+      rootStream.moveNext();
+      var second = rootStream.current;
+      roots.add(new Reference(this, first, second));
     }
     var x = inflateReference(roots[0]);
     return inflateReference(roots.first);
   }
 
   /**
    * Inflate all of the objects for [rule]. Does the essential state for all
    * objects first, then the non-essential state. This avoids cycles in
    * non-essential state, because all the objects will have already been
    * created.
@@ skipping 197 matching lines @@
  * found for it. This normally only makes sense if the object is uniquely
  * referenced, and is a more or less internal collection. See ListRuleEssential
  * 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.filter(rulePredicate);
+  possibleRules(List rules) => rules.where(rulePredicate).toList();
 }