Better ability to have hand-written custom rules and various cleanups.

pkg/serialization/lib/src/basic_rule.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;
 
 // TODO(alanknight): Figure out how to reasonably separate out the things
 // that require reflection without making the API more awkward. Or if that is
 // in fact necessary. Maybe the tree-shaking will just remove it if unused.
 
@@ skipping 152 matching lines @@
 
   /**
    * If the value is a List, and the field is a constructor field or
    * otherwise specially designated, we wrap it in something that indicates
    * a restriction on the rules that can be used. Which in this case amounts
    * to designating the rule, since we so far only have one rule per object.
    */
   checkForEssentialLists(index, value) {
     if (value is List && fields.contents[index].isEssential) {
       return new DesignatedRuleForObject(value,
-          (index) => index is ListRuleEssential);
+          (SerializationRule rule) => rule is ListRuleEssential);
     } else {
       return value;
     }
   }
 
   /** Remove any MapWrapper from the extracted state. */
   _unwrap(result) => (result is _MapWrapper) ? result.asMap() : result;
 
   /**
    * Call the designated constructor with the appropriate fields from [state],
@@ skipping 15 matching lines @@
       var value = reader.inflateReference(state[field.index]);
       field.setValue(mirror, value);
     });
   }
 
   /**
    * Determine if this rule applies to the object in question. In our case
    * this is true if the type mirrors are the same.
    */
   // TODO(alanknight): This seems likely to be slow. Verify. Other options?
-  bool appliesTo(object) => reflect(object).type == type;
+  bool appliesTo(object, Writer w) => reflect(object).type == type;
 
   /**
    * Given the various field lists provided by the user, construct the list
    * of field names that we want.
    */
   void _findFields(List constructorFields, List regularFields,
       List excludeFields) {
     fields = new _FieldList(type);
     fields.constructorFields = constructorFields;
     fields.regular = regularFields;
@@ skipping 265 matching lines @@
     addAllNotExplicitlyExcluded(names(fields));
     addAllNotExplicitlyExcluded(names(gettersWithSetters));
     addAllNotExplicitlyExcluded(names(gettersThatMatchConstructor));
   }
 }
 
 /**
  *  Provide a typedef for the setWith argument to specialTreatmentFor. It would
  * be nice if we could put this closer to the definition.
  */
-typedef SetWithFunction(InstanceMirror m, Object o);
+typedef SetWithFunction(InstanceMirror m, object);
 
 /**
  * This represents a constructor that is to be used when re-creating a
  * serialized object.
  */
 class Constructor {
   /** The mirror of the class we construct. */
   final ClassMirror type;
 
   /** The name of the constructor to use, if not the default constructor.*/
@@ skipping 37 matching lines @@
   List fieldList;
   _MapWrapper(this.fieldList);
   _MapWrapper.fromMap(this._map, this.fieldList);
 
   operator [](key) => _map[fieldList[key].name];
   operator []=(key, value) { _map[fieldList[key].name] = value; }
   get length => _map.length;
 
   asMap() => _map;
 }