pkg/serialization updates

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.
 
 /**
  * This is the basic rule for handling "normal" objects, which have a list of
  * fields and a constructor, as opposed to simple types or collections. It uses
  * mirrors to access the state, and can also use them to figure out the list
  * of fields and the constructor if it's not provided.
  *
  * If you call [Serialization.addRule], this is what you get.
  *
  */
 class BasicRule extends SerializationRule {
   /**
    * The [type] is used both to find fields and to verify if the object is one
    * that we handle.
    */
   final ClassMirror type;
 
   /** Used to create new objects when reading. */
-  Constructor constructor;
+  final Constructor constructor;
 
   /** This holds onto our list of fields, and can also calculate them. */
-  _FieldList _fields;
+  final _FieldList _fields;
 
   /**
    * Instances can either use maps or lists to hold the object's state. The list
    * representation is much more compact and used by default. The map
    * representation is more human-readable. The default is to use lists.
    */
   bool useMaps = false;
 
   // TODO(alanknight) Change the type parameter once we have class literals.
   // Issue 6282.
   // TODO(alanknight) Does the comment for this format properly?
   /**
    * Create this rule. Right now the user is obliged to pass a ClassMirror,
    * but once we allow class literals (Issue 6282) it will support that. The
    * other parameters can all be left as null, and are optional on the
    * [Serialization.addRule] method which is the normal caller for this.
    * [constructorName] is the constructor, if not the default.
    * [constructorFields] are the fields required to call the constructor, which
    *   is the essential state. They don't have to be actual fields,
    *   getter/setter pairs or getter/constructor pairs are fine. Note that
    *   the constructorFields do not need to be strings, they can be arbitrary
    *   values. For non-strings, these will be treated as constant values to be
    *   used instead of data read from the objects.
    * [regularFields] are the non-essential fields. They don't have to be actual
    *   fields, getter/setter pairs are fine. If this is null, it's assumed
    *   that we should figure them out.
    * [excludeFields] lets you tell it to find the fields automatically, but
    *   omit some that would otherwise be included.
    */
-  BasicRule(ClassMirror this.type, String constructorName,
-      List constructorFields, List regularFields,
-      List excludeFields) {
-    _findFields(constructorFields, regularFields, excludeFields);
-    constructor = new Constructor(
-        type, constructorName, _fields.constructorFieldIndices());
+  factory BasicRule(ClassMirror type, String constructorName,
+      List constructorFields, List regularFields, List excludeFields) {
+
+    var fields = new _FieldList(type);
+    fields.constructorFields = constructorFields;
+    fields.regular = regularFields;
+    // TODO(alanknight): The order of this matters. It shouldn't.
+    fields.exclude = excludeFields;
+    fields.figureOutFields();
+
+    var constructor = new Constructor(type, constructorName,
+        fields.constructorFieldIndices());
+
+    return new BasicRule._(type, constructor, fields);
+  }
+
+  BasicRule._(this.type, this.constructor, this._fields) {
     configureForLists();
   }
 
   /**
    * Sometimes it's necessary to treat fields of an object differently, based
    * on the containing object. For example, by default a list treats its
    * contents as non-essential state, so it will be populated only after all
    * objects have been created. An object may have a list which is used in its
    * constructor and must be fully created before the owning object can be
    * created. Alternatively, it may not be possible to set a field directly,
@@ skipping 159 matching lines @@
     });
   }
 
   /**
    * 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, 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;
-    // TODO(alanknight): The order of this matters. It shouldn't.
-    _fields.exclude = excludeFields;
-    _fields.figureOutFields();
-  }
-
   bool get hasVariableLengthEntries => false;
 
   int get dataLength => _fields.length;
 
   /**
    * Extract the value of [field] from the object reflected
    * by [mirror].
    */
   // TODO(alanknight): The framework should be resilient if there are fields
   // it expects that are missing, either for the case of de-serializing to a
@@ skipping 403 matching lines @@
   if (value is String) {
     try {
       return new Symbol(value);
     } on ArgumentError {
       return null;
     };
   } else {
     return null;
   }
 }