pkg/serialization types cleanup

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 10 matching lines @@
   /**
    * 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;
 
   /** This holds onto our list of fields, and can also calculate them. */
-  _FieldList fields;
+  _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.
@@ skipping 14 matching lines @@
    *   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());
+        type, constructorName, _fields.constructorFieldIndices());
     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,
    * and some other method must be called to set it, perhaps calling a method
    * on the owning object to add each individual element.
    *
    * This method lets you designate a function to use to set the value of a
    * field. It also makes the contents of that field be treated as essential,
    * which currently only has meaning if the field is a list. This is done
    * because you might set a list field's special treatment function to add
    * each item individually and that will only work if those objects already
    * exist.
    *
    * For example, to serialize a Serialization, we need its rules to be
    * individually added rather than just setting the rules field.
    *      ..addRuleFor(new Serialization()).setFieldWith('rules',
    *          (InstanceMirror s, List rules) {
    *            rules.forEach((x) => s.reflectee.addRule(x));
    * Note that the function is passed the owning object as well as the field
    * value, but that it is passed as a mirror.
    */
-  setFieldWith(String fieldName, SetWithFunction setWith) {
-    fields.addAllByName([fieldName]);
-    _NamedField field = fields.named(_asSymbol(fieldName));
+  void setFieldWith(String fieldName, SetWithFunction setWith) {
+    _fields.addAllByName([fieldName]);
+    _NamedField field = _fields.named(_asSymbol(fieldName));
     Function setter = (setWith == null) ? field.defaultSetter : setWith;
     field.customSetter = setter;
   }
 
   /** Return the name of the constructor used to create new instances on read.*/
   String get constructorName => constructor.name;
 
   /** Return the list of field names to be passed to the constructor.*/
-  List<String> get constructorFields => fields.constructorFieldNames();
+  List<String> get constructorFields => _fields.constructorFieldNames();
 
   /** Return the list of field names not used in the constructor. */
-  List<String> get regularFields => fields.regularFieldNames();
+  List<String> get regularFields => _fields.regularFieldNames();
 
   String toString() => "Basic Rule for ${type.simpleName}";
 
   /**
    * Configure this instance to use maps by field name as its output.
    * Instances can either produce maps or lists. The list representation
    * is much more compact and used by default. The map representation is
    * much easier to debug. The default is to use lists.
    */
-  configureForMaps() {
+  void configureForMaps() {
     useMaps = true;
   }
 
   /**
    * Configure this instance to use lists accessing fields by index as its
    * output. Instances can either produce maps or lists. The list representation
    * is much more compact and used by default. The map representation is
    * much easier to debug. The default is to use lists.
    */
-  configureForLists() {
+  void configureForLists() {
     useMaps = false;
   }
 
   /**
    * Create either a list or a map to hold the object's state, depending
    * on the [useMaps] variable. If using a Map, we wrap it in order to keep
    * the protocol compatible. See [configureForLists]/[configureForMaps].
    *
    * If a list is returned, it is growable.
    */
    createStateHolder() {
-     if (useMaps) return new _MapWrapper(fields.contents);
+     if (useMaps) return new _MapWrapper(_fields.contents);
      List list = [];
-     list.length = fields.length;
+     list.length = _fields.length;
      return list;
    }
 
   /**
    * Wrap the state if it's passed in as a map, and if the keys are references,
    * resolve them to the strings we expect. We leave the previous keys in there
    * as well, as they shouldn't be harmful, and it costs more to remove them.
    */
    makeIndexableByNumber(state) {
      if (!(state is Map)) return state;
      // TODO(alanknight): This is quite inefficient, and we do it twice per
      // instance. If the keys are references, we need to turn them into strings
      // before we can look at indexing them by field position. It's also eager,
      // but we know our keys are always primitives, so we don't have to worry
      // about their instances not having been created yet.
      var newState = new Map();
      for (var each in state.keys) {
        var newKey = (each is Reference) ? each.inflated() : each;
        newState[newKey] = state[each];
      }
-     return new _MapWrapper.fromMap(newState, fields.contents);
+     return new _MapWrapper.fromMap(newState, _fields.contents);
    }
 
   /**
    * Extract the state from [object] using an instanceMirror and the field
-   * names in [fields]. Call the function [callback] on each value.
+   * names in [_fields]. Call the function [callback] on each value.
    */
   extractState(object, Function callback, Writer w) {
     var result = createStateHolder();
     var mirror = reflect(object);
 
-    keysAndValues(fields).forEach(
+    keysAndValues(_fields).forEach(
         (index, field) {
           var value = _value(mirror, field);
           callback(field.name);
           callback(checkForEssentialLists(index, value));
           result[index] = value;
         });
     return _unwrap(result);
   }
 
   flatten(state, Writer writer) {
@@ skipping 10 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) {
+    if (value is List && _fields.contents[index].isEssential) {
       return new DesignatedRuleForObject(value,
           (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],
    * first resolving references in the context of [reader].
    */
   inflateEssential(state, Reader reader) {
     InstanceMirror mirror = constructor.constructFrom(
         makeIndexableByNumber(state), reader);
     return mirror.reflectee;
   }
 
   /** For all [rawState] not required in the constructor, set it in the
    * [object], resolving references in the context of [reader].
    */
   inflateNonEssential(rawState, object, Reader reader) {
     InstanceMirror mirror = reflect(object);
     var state = makeIndexableByNumber(rawState);
-    fields.forEachRegularField( (_Field field) {
+    _fields.forEachRegularField( (_Field field) {
       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, 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;
+    _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();
+    _fields.exclude = excludeFields;
+    _fields.figureOutFields();
   }
 
   bool get hasVariableLengthEntries => false;
 
-  int get dataLength => fields.length;
+  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
   // different definition, or for the case that tree-shaking has removed state.
   // TODO(alanknight): This, and other places, rely on synchronous access to
   // mirrors. Should be changed to use a synchronous API once one is available,
@@ skipping 62 matching lines @@
    * using [BasicRule.setFieldWith].
    */
   bool get isEssential => usedInConstructor;
 
   /** Set the [value] of our field in the given mirrored [object]. */
   void setValue(InstanceMirror object, value);
 
   // Because [x] may not be a named field, we compare the toString. We don't
   // care that much where constants come in the sort order as long as it's
   // consistent.
-  compareTo(_Field x) => toString().compareTo(x.toString());
+  int compareTo(_Field x) => toString().compareTo(x.toString());
 }
 
 /**
  * This represents a field in the object, either stored as a field or
  * accessed via getter/setter/constructor parameter. It has a name and
  * will attempt to access the state for that name using an [InstanceMirror].
  */
 class _NamedField extends _Field {
   /** The name of the field (or getter) */
   String _name;
@@ skipping 67 matching lines @@
    * use the value for that.
    */
   get name => value;
 }
 
 /**
  * The organization of fields in an object can be reasonably complex, so they
  * are kept in a separate object, which also has the ability to compute the
  * default fields to use reflectively.
  */
-class _FieldList extends IterableBase {
+class _FieldList extends IterableBase<_Field> {
   /**
    * All of our fields, indexed by name. Note that the names are
    * typically Symbols, but can also be arbitrary constants.
    */
   Map<dynamic, _Field> allFields = new Map<dynamic, _Field>();
 
   /**
    * The fields which are used in the constructor. The fields themselves also
    * know if they are constructor fields or not, but we need to keep this
    * information here because the order matters.
@@ skipping 72 matching lines @@
 
   /**
    * Fields have been added. In case we had already forced calculation of the
    * list of contents, re-set it.
    */
   void invalidate() {
     _contents = null;
     contents;
   }
 
-  Iterator get iterator => contents.iterator;
+  Iterator<_Field> get iterator => contents.iterator;
 
   /** Return a cached, sorted list of all the fields. */
   List<_Field> get contents {
     if (_contents == null) {
       _contents = sorted(allFields.values);
       for (var i = 0; i < _contents.length; i++)
         _contents[i].index = i;
     }
     return _contents;
   }
@@ skipping 106 matching lines @@
     }
     return result;
   }
 }
 
 /**
  * This wraps a map to make it indexable by integer field numbers. It translates
  * from the index into a field name and then looks it up in the map.
  */
 class _MapWrapper {
-  final _map;
-  List fieldList;
+  final Map _map;
+  final List fieldList;
   _MapWrapper(this.fieldList) : _map = new Map();
   _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;
+  Map asMap() => _map;
 }
 
 /**
  * Return a symbol corresponding to [value], which may be a String or a
  * Symbol. If it is any other type, or if the string is an
  * invalid symbol, return null;
  */
-_asSymbol(value) {
+Symbol _asSymbol(value) {
   if (value is Symbol) return value;
   if (value is String) {
     try {
       return new Symbol(value);
     } on ArgumentError {
       return null;
     };
   } else {
     return null;
   }
 }