Update pkg/serialization to use Symbols and synchronous mirrors

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 76 matching lines @@
    * 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(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();
 
@@ skipping 195 matching lines @@
     } else {
       return new _ConstantField._internal(value, fieldList);
     }
   }
 
   /**
    * Determine if [value] represents a field or getter in the class that
    * [fieldList] models.
    */
   static bool _isReallyAField(value, _FieldList fieldList) {
-    if (!(value is String)) return false;
-    return hasField(value, fieldList.mirror) ||
-        hasGetter(value, fieldList.mirror);
+    var symbol = _asSymbol(value);
+    return hasField(symbol, fieldList.mirror) ||
+        hasGetter(symbol, fieldList.mirror);
   }
 
   /** Private constructor. */
   _Field._internal(this.fieldList);
 
   /**
    * Extracts the value for the field that this represents from the instance
    * mirrored by [mirror] and return it.
    */
   valueIn(InstanceMirror mirror);
@@ skipping 19 matching lines @@
   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) */
-  final name;
+  String _name;
+  Symbol nameSymbol;
 
-  /** The special way to set this value registered, if this has a value. */
+  /**
+   * If this is set, then it is used as a way to set the value rather than
+   * using the default mechanism.
+   */
   Function customSetter;
 
-  _NamedField._internal(this.name, fieldList) : super._internal(fieldList);
+  _NamedField._internal(fieldName, fieldList) : super._internal(fieldList) {
+    nameSymbol = _asSymbol(fieldName);
+    if (nameSymbol == null) {
+      throw new SerializationException("Invalid field name $fieldName");
+    }
+  }
 
-  operator ==(x) => x is _NamedField && (name == x.name);
+  String get name =>
+      _name == null ? _name = MirrorSystem.getName(nameSymbol) : _name;
+
+  operator ==(x) => x is _NamedField && (nameSymbol == x.nameSymbol);
   int get hashCode => name.hashCode;
 
   /**
    * Return true if this field is treated as essential state, either because
    * 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) =>
-      deprecatedFutureValue(mirror.getFieldAsync(name)).reflectee;
+  valueIn(InstanceMirror mirror) => mirror.getField(nameSymbol).reflectee;
 
   /** Return the function to use to set our value. */
   Function get setter =>
       (customSetter != null) ? customSetter : defaultSetter;
 
-  /** Return a default setter function. */
+  /** The default setter function. */
   void defaultSetter(InstanceMirror object, value) {
-    object.setFieldAsync(name, reflect(value));
+    object.setField(nameSymbol, value);
   }
 
   String toString() => 'Field($name)';
 }
 
 /**
  * This represents a constant value that will be passed as a constructor
  * parameter. Rather than having a name it has a constant value.
  */
 class _ConstantField extends _Field {
@@ skipping 17 matching lines @@
   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 {
   /**
-   * All of our fields, indexed by name. Note that the names are not
-   * necessarily strings.
+   * 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.
    */
   List _constructorFields = const [];
 
   /** The list of fields to exclude if we are computing the list ourselves. */
-  List<String> _excludeFields = const [];
+  List<Symbol> _excludedFieldNames = const [];
 
   /** The mirror we will use to compute the fields. */
   final ClassMirror mirror;
 
   /** Cached, sorted list of fields. */
   List<_Field> _contents;
 
   /** Should we compute the fields or just use whatever we were given. */
   bool _shouldFigureOutFields = true;
 
   _FieldList(this.mirror);
 
   /** Look up a field by [name]. */
-  _Field named(String name) => allFields[name];
+  _Field named(name) => allFields[name];
 
   /** Set the fields to be used in the constructor. */
   set constructorFields(List fieldNames) {
     if (fieldNames == null || fieldNames.isEmpty) return;
     _constructorFields = [];
     for (var each in fieldNames) {
-      var field = new _Field(each, this)..usedInConstructor = true;
-      allFields[each] = field;
+      var symbol = _asSymbol(each);
+      var name = _Field._isReallyAField(symbol, this) ? symbol : each;
+      var field = new _Field(name, this)..usedInConstructor = true;
+      allFields[name] = field;
       _constructorFields.add(field);
     }
     invalidate();
   }
 
   /** Set the fields that aren't used in the constructor. */
   set regular(List<String> fields) {
     if (fields == null) return;
     _shouldFigureOutFields = false;
     addAllByName(fields);
   }
 
   /** Set the fields to be excluded. This is mutually exclusive with setting
    * the regular fields.
    */
   set exclude(List<String> fields) {
     // TODO(alanknight): This isn't well tested.
     if (fields == null || fields.isEmpty) return;
     if (allFields.length > _constructorFields.length) {
       throw "You can't specify both excludeFields and regular fields";
     }
-    _excludeFields = fields;
+    _excludedFieldNames = fields.map((x) => new Symbol(x)).toList();
   }
 
   int get length => allFields.length;
 
   /** Add all the fields which aren't on the exclude list. */
   void addAllNotExplicitlyExcluded(Iterable<String> aCollection) {
     if (aCollection == null) return;
     var names = aCollection;
-    names = names.where((x) => !_excludeFields.contains(x));
+    names = names.where((x) => !_excludedFieldNames.contains(x));
     addAllByName(names);
   }
 
   /** Add all the fields with the given names without any special properties. */
   void addAllByName(Iterable<String> names) {
     for (var each in names) {
-      allFields.putIfAbsent(each, () => new _Field(each, this));
+      var symbol = _asSymbol(each);
+      var field = new _Field(symbol, this);
+      allFields.putIfAbsent(symbol, () => new _Field(symbol, 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;
@@ skipping 47 matching lines @@
    * that are listed in the constructor fields.
    */
   void figureOutFields() {
     Iterable names(Iterable<DeclarationMirror> mirrors) =>
         mirrors.map((each) => each.simpleName).toList();
 
     if (!_shouldFigureOutFields || !regularFields().isEmpty) return;
     var fields = publicFields(mirror);
     var getters = publicGetters(mirror);
     var gettersWithSetters = getters.where( (each)
-        => mirror.setters["${each.simpleName}="] != null);
+        => mirror.setters[
+            new Symbol("${MirrorSystem.getName(each.simpleName)}=")] != null);
     var gettersThatMatchConstructor = getters.where((each)
         => (named(each.simpleName) != null) &&
             (named(each.simpleName).usedInConstructor)).toList();
     addAllNotExplicitlyExcluded(names(fields));
     addAllNotExplicitlyExcluded(names(gettersWithSetters));
     addAllNotExplicitlyExcluded(names(gettersThatMatchConstructor));
   }
 
   toString() => "FieldList($contents)";
 }
 
 /**
  *  Provide a typedef for the setWith argument to setFieldWith. It would
  * be nice if we could put this closer to the definition.
  */
 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.*/
   String name;
+  Symbol nameSymbol;
 
   /**
    * The indices of the fields used as constructor arguments. We will look
    * these up in the state by number. These correspond to the index in the
    * [contents] of the FieldList, which will be alphabetically sorted.
    */
   List<int> fieldNumbers;
 
   /**
    * Creates a new constructor for the [type] with the constructor named [name]
    * and the [fieldNumbers] of the constructor fields.
    */
   Constructor(this.type, this.name, this.fieldNumbers) {
     if (name == null) name = '';
+    nameSymbol = new Symbol(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
     Iterable inflated = fieldNumbers.map(
-        (x) => (x is int) ? reflect(r.inflateReference(state[x])) : reflect(x));
-    var result = type.newInstanceAsync(name, inflated.toList());
-    return deprecatedFutureValue(result);
+        (x) => (x is int) ? r.inflateReference(state[x]) : x);
+    var result;
+    try {
+      result = type.newInstance(nameSymbol, inflated.toList());
+    } on MirroredError catch (e) {
+      // Mirrored "compile-time" errors do not get treated as exceptions
+      // in the debugger, so explicitly re-throw. Issue dartbug.com/10054.
+      throw e;
+    }
+    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;
   _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;
 }
+
+/**
+ * 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) {
+  if (value is Symbol) return value;
+  if (value is String) {
+    try {
+      return new Symbol(value);
+    } on ArgumentError {
+      return null;
+    };
+  } else {
+    return null;
+  }
+}