Rename mappedBy to map.

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 179 matching lines @@
    */
   int _objectNumberFor(object) {
     var reference = references[object];
     return (reference == null) ? -1 : reference.objectNumber;
   }
 
   /**
    * Return a list of [Reference] objects pointing to our roots. This will be
    * stored in the output under "roots" in the default format.
    */
-  _rootReferences() => trace.roots.mappedBy(_referenceFor).toList();
+  _rootReferences() => trace.roots.map(_referenceFor).toList();
 
   /**
    * Given an object, return a reference for it if one exists. If there's
    * 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;
@@ skipping 113 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.mappedBy((x) => new List(x.length)).toList();
+    objects = _data.map((x) => new List(x.length)).toList();
   }
 
   /**
    * This is the primary method for a [Reader]. It takes the input data,
    * decodes it according to [format] and returns the root object.
    */
   read(rawInput, [Map externals = const {}]) {
     namedObjects = externals;
     var input = format.read(rawInput, this);
     data = input["data"];
@@ skipping 255 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();
 }