Big merge from experimental to bleeding edge.

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 221 matching lines @@
   _value(InstanceMirror mirror, _Field field) => field.valueIn(mirror);
 
   /**
    * When reading from a flat format we are given [stream] and need to pull as
    * much data from it as we need. Our format is that we have an integer N
    * indicating the number of objects and then for each object N fields, which
    * are references, where a reference is stored in the stream as two integers.
    * Or, in the special case of null, two nulls.
    */
   pullStateFrom(Iterator stream) {
-    var dataLength = stream.next();
+    stream.moveNext();
+    var dataLength = stream.current;
     var ruleData = new List();
     for (var i = 0; i < dataLength; i++) {
       var subList = new List();
       ruleData.add(subList);
       for (var j = 0; j < fields.length; j++) {
-        var a = stream.next();
-        var b = stream.next();
+        stream.moveNext();
+        var a = stream.current;
+        stream.moveNext();
+        var b = stream.current;
         if (!(a is int)) {
           // This wasn't a reference, so just use the first object as a literal.
           // particularly used for the case of null.
           subList.add(a);
         } else {
           subList.add(new Reference(this, a, b));
         }
       }
     }
     return ruleData;
@@ skipping 93 matching lines @@
    * it is used in the constructor, or because it's been designated
    * using [setFieldWith].
    */
   bool get isEssential => super.isEssential || customSetter != null;
 
   /** Set the [value] of our field in the given mirrored [object]. */
   void setValue(InstanceMirror object, value) {
     setter(object, value);
   }
 
-  valueIn(InstanceMirror mirror) => mirror.getField(name).value.reflectee;
+  valueIn(InstanceMirror mirror) {
+    var futureValue = deprecatedFutureValue(mirror.getField(name));
+    return futureValue.reflectee;
+  }
 
   /** Return the function to use to set our value. */
   Function get setter =>
       (customSetter != null) ? customSetter : defaultSetter;
 
   /** Return a default setter function. */
   void defaultSetter(InstanceMirror object, value) {
     object.setField(name, reflect(value));
   }
 
@@ skipping 23 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 implements Iterable {
+class _FieldList extends Iterable {
   /**
    * All of our fields, indexed by name. Note that the names are not
    * necessarily strings.
    */
   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 47 matching lines @@
     }
     _excludeFields = fields;
   }
 
   int get length => allFields.length;
 
   /** Add all the fields which aren't on the exclude list. */
   void addAllNotExplicitlyExcluded(List<String> aCollection) {
     if (aCollection == null) return;
     var names = aCollection;
-    names = names.filter((x) => !_excludeFields.contains(x));
+    names = names.where((x) => !_excludeFields.contains(x));
     addAllByName(names);
   }
 
   /** Add all the fields with the given names without any special properties. */
-  void addAllByName(List<String> names) {
+  void addAllByName(Iterable<String> names) {
     for (var each in names) {
       allFields.putIfAbsent(each, () => new _Field(each, this));
     }
     invalidate();
   }
 
   /**
    * 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 iterator() => contents.iterator();
+  Iterator 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 10 matching lines @@
   /** Iterate over the fields used in the constructor. */
   void forEachConstructorField(Function f) {
     for (var each in contents) {
       if (each.usedInConstructor) {
         f(each);
       }
     }
   }
 
   List get constructorFields => _constructorFields;
-  List constructorFieldNames() => constructorFields.map((x) => x.name);
-  List constructorFieldIndices() => constructorFields.map((x) => x.index);
-  List regularFields() => contents.filter((x) => !x.usedInConstructor);
-  List regularFieldNames() => regularFields().map((x) => x.name);
-  List regularFieldIndices() => regularFields().map((x) => x.index);
+  List constructorFieldNames() =>
+      constructorFields.mappedBy((x) => x.name).toList();
+  List constructorFieldIndices() =>
+      constructorFields.mappedBy((x) => x.index).toList();
+  List regularFields() =>
+      contents.where((x) => !x.usedInConstructor).toList();
+  List regularFieldNames() =>
+      regularFields().mappedBy((x) => x.name).toList();
+  List regularFieldIndices() =>
+      regularFields().mappedBy((x) => x.index).toList();
 
 
   /**
    * If we weren't given any non-constructor fields to use, figure out what
    * we think they ought to be, based on the class definition.
    * We find public fields, getters that have corresponding setters, and getters
    * that are listed in the constructor fields.
    */
   void figureOutFields() {
     List names(Collection<DeclarationMirror> mirrors) =>
-        mirrors.map((each) => each.simpleName);
+        mirrors.mappedBy((each) => each.simpleName).toList();
 
     if (!_shouldFigureOutFields || !regularFields().isEmpty) return;
     var fields = publicFields(mirror);
     var getters = publicGetters(mirror);
-    var gettersWithSetters = getters.filter( (each)
-        => mirror.setters["${each.simpleName}="] != null);
-    var gettersThatMatchConstructor = getters.filter((each)
+    var gettersWithSetters = getters.where( (each)
+        => mirror.setters["${each.simpleName}="] != null).toList();
+    var gettersThatMatchConstructor = getters.where((each)
         => (named(each.simpleName) != null) &&
-            (named(each.simpleName).usedInConstructor));
+            (named(each.simpleName).usedInConstructor)).toList();
     addAllNotExplicitlyExcluded(names(fields));
     addAllNotExplicitlyExcluded(names(gettersWithSetters));
     addAllNotExplicitlyExcluded(names(gettersThatMatchConstructor));
   }
 }
 
 /**
  *  Provide a typedef for the setWith argument to setFieldWith. It would
  * be nice if we could put this closer to the definition.
  */
@@ skipping 25 matching lines @@
     if (name == null) name = '';
     if (fieldNumbers == null) fieldNumbers = const [];
   }
 
   /**
    * Find the field values in [state] and pass them to the constructor.
    * If any of [fieldNumbers] is not an int, then use it as a literal value.
    */
   constructFrom(state, Reader r) {
     // TODO(alanknight): Handle named parameters
-    Collection inflated = fieldNumbers.map(
-        (x) => (x is int) ? reflect(r.inflateReference(state[x])) : reflect(x));
+    Collection inflated = fieldNumbers.mappedBy(
+        (x) => (x is int) ? reflect(r.inflateReference(state[x])) : reflect(x))
+        .toList();
     var result = type.newInstance(name, inflated);
-    return result.value;
+    return deprecatedFutureValue(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 {
   Map<String, dynamic> _map = new Map<String, dynamic>();
   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;
-}
+}