Fix serialization doc bug, update to use class literals in a few more places

pkg/serialization/lib/serialization.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.
 
 /**
  * A general-purpose serialization facility for Dart objects.
  *
  * A [Serialization] is defined in terms of [SerializationRule]s and supports
  * reading and writing to different formats.
  *
@@ skipping 91 matching lines @@
  *                addressToMap, createAddress, fillInAddress);
  *
  * In this case we have created standalone functions rather than
  * methods in a subclass and we pass them to the constructor of
  * [ClosureRule]. In this case we've also had them use maps rather than
  * lists for the state, but either would work as long as the rule is
  * consistent with the representation it uses. We pass it the runtimeType
  * of the object, and functions equivalent to the methods on [CustomRule]
  *
  * ## Constant values
- * 
+ *
  * There are cases where the constructor needs values that we can't easily get
  * from the serialized object. For example, we may just want to pass null, or a
  * constant value. To support this, we can specify as constructor fields
  * values that aren't field names. If any value isn't a String, or is a string
  * that doesn't correspond to a field name, it will be
  * treated as a constant and passed unaltered to the constructor.
  *
  * In some cases a non-constructor field should not be set using field
  * access or a setter, but should be done by calling a method. For example, it
  * may not be possible to set a List field "foo", and you need to call an
  * addFoo() method for each entry in the list. In these cases, if you are using
  * a BasicRule for the object you can call the setFieldWith() method.
  *
- *       s..addRuleFor(fooHolderInstance).setFieldWith("foo",
+ *       s..addRuleFor(FooHolder).setFieldWith("foo",
  *           (parent, value) => for (var each in value) parent.addFoo(value));
  *
  * ## Writing
  *
  * To write objects, we use the write() method.
  *
  *       var output = serialization.write(someObject);
  *
  * By default this uses a representation in which objects are represented as
  * maps keyed by field name, but in which references between objects have been
@@ skipping 208 matching lines @@
    * method.
    */
   void addRule(SerializationRule rule) {
     rule.number = _rules.length;
     _rules.add(rule);
   }
 
   /**
    * This writes out an object graph rooted at [object] and returns the result.
    * The [format] parameter determines the form of the result. The default
-   * format returns a String in [json] format.
+   * format is [SimpleMapFormat] and returns a Map.
    */
   write(Object object, {Format format}) {
     return newWriter(format).write(object);
   }
 
   /**
    * Return a new [Writer] object for this serialization. This is useful if you
    * want to do something more complex with the writer than just returning
    * the final result.
    */
   Writer newWriter([Format format]) => new Writer(this, format);
 
   /**
    * Read the serialized data from [input] and return the root object
    * from the result. The [input] can be of any type that the [Format]
    * reads/writes, but normally will be a [List], [Map], or a simple type.
    * The [format] parameter determines the form of the result. The default
-   * format returns a String in [json] format.
+   * format is [SimpleMapFormat] and expects a Map as input.
    * If there are objects that need to be resolved
    * in the current context, they should be provided in [externals] as a
    * Map from names to values. In particular, in the current implementation
    * any class mirrors needed should be provided in [externals] using the
    * class name as a key. In addition to the [externals] map provided here,
    * values will be looked up in the [namedObjects] map.
    */
   read(input, {Format format, Map externals: const {}}) {
     return newReader(format).read(input, externals);
   }
@@ skipping 56 matching lines @@
    * If there are new rule classes created, they will need to be described
    * here.
    */
   Serialization ruleSerialization() {
     // TODO(alanknight): There's an extensibility issue here with new rules.
     // TODO(alanknight): How to handle rules with closures? They have to
     // exist on the other side, but we might be able to hook them up by name,
     // or we might just be able to validate that they're correctly set up
     // on the other side.
 
-    // Make some bogus rule instances so we have something to feed rule creation
-    // and get their types. If only we had class literals implemented...
-   var basicRule = new BasicRule(reflect(null).type, '', [], [], []);
-
     var meta = new Serialization()
       ..selfDescribing = false
-      ..addRuleFor(new ListRule())
-      ..addRuleFor(new MapRule())
-      ..addRuleFor(new PrimitiveRule())
-      ..addRuleFor(new ListRuleEssential())
-      ..addRuleFor(basicRule,
+      ..addRuleFor(ListRule)
+      ..addRuleFor(MapRule)
+      ..addRuleFor(PrimitiveRule)
+      ..addRuleFor(ListRuleEssential)
+      ..addRuleFor(BasicRule,
           constructorFields: ['type',
             'constructorName',
             'constructorFields', 'regularFields', []],
           fields: [])
       ..addRule(new NamedObjectRule())
       ..addRule(new MirrorRule())
-      ..addRuleFor(new MirrorRule())
-      ..addRuleFor(new SymbolRule())
-      ..addRuleFor(new DateTimeRule());
+      ..addRuleFor(MirrorRule)
+      ..addRuleFor(SymbolRule)
+      ..addRuleFor(DateTimeRule);
     meta.namedObjects = namedObjects;
     return meta;
   }
 
   /** Return true if our [namedObjects] collection has an entry for [object].*/
   bool _hasNameFor(object) {
     var sentinel = const _Sentinel();
     return _nameFor(object, () => sentinel) != sentinel;
   }
 
@@ skipping 10 matching lines @@
 }
 
 /**
  * An exception class for errors during serialization.
  */
 class SerializationException implements Exception {
   final String message;
   const SerializationException(this.message);
   String toString() => "SerializationException($message)";
 }