Some fixes to work better with the services framework

pkg/serialization/lib/src/serialization_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): We should have an example and tests for subclassing
 // serialization rule rather than using the hard-coded ClosureToMap rule. And
 // possibly an abstract superclass that's designed to be subclassed that way.
 /**
@@ skipping 27 matching lines @@
    * where we're writing it, false otherwise.
    */
   bool appliesTo(object, Writer writer);
 
   /**
    * This extracts the state from the object, calling [f] for each value
    * as it is extracted, and returning an object representing the whole
    * state at the end. The state that results will still have direct
    * pointers to objects, rather than references.
    */
-  extractState(object, void f(value));
+  extractState(object, void f(value), Writer w);
 
   /**
    * Allows rules to tell us how they expect to store their state. If this
    * isn't specified we can also just look at the data to tell.
    */
   bool get storesStateAsLists => false;
   bool get storesStateAsMaps => false;
   bool get storesStateAsPrimitives => false;
 
   /**
@@ skipping 76 matching lines @@
 /**
  * This rule handles things that implement List. It will recreate them as
  * whatever the default implemenation of List is on the target platform.
  */
 class ListRule extends SerializationRule {
 
   appliesTo(object, Writer w) => object is List;
 
   bool get storesStateAsLists => true;
 
-  List extractState(List list, f) {
+  List extractState(List list, f, Writer w) {
     var result = new List();
     for (var each in list) {
       result.add(each);
       f(each);
     }
     return result;
   }
 
   inflateEssential(List state, Reader r) => new List();
 
@@ skipping 37 matching lines @@
  * whatever the default implemenation of Map is on the target platform. If a
  * map has string keys it will attempt to retain it as a map for JSON formats,
  * otherwise it will store it as a list of references to keys and values.
  */
 class MapRule extends SerializationRule {
 
   appliesTo(object, Writer w) => object is Map;
 
   bool get storesStateAsMaps => true;
 
-  extractState(Map map, f) {
+  extractState(Map map, f, Writer w) {
     // Note that we make a copy here because flattening may be destructive.
     var newMap = new Map.from(map);
     newMap.forEach((key, value) {
       f(key);
       f(value);
     });
     return newMap;
   }
 
   /**
    * Change the keys and values of [state] into references in [writer].
    * If [state] is a map whose keys are all strings then we leave the keys
    * as is so that JSON formats will be more readable. If the keys are
    * arbitrary then we need to turn them into references and replace the
    * state with a new Map whose keys are the references.
    */
   flatten(Map state, Writer writer) {
     bool keysAreAllStrings = state.keys.every((x) => x is String);
-    if (keysAreAllStrings) {
+    if (keysAreAllStrings && !writer.shouldUseReferencesForPrimitives) {
       keysAndValues(state).forEach(
           (key, value) => state[key] = writer._referenceFor(value));
       return state;
     } else {
       var newState = [];
       keysAndValues(state).forEach((key, value) {
         newState.add(writer._referenceFor(key));
         newState.add(writer._referenceFor(value));
       });
       return newState;
@@ skipping 35 matching lines @@
 
 /**
  * This rule handles primitive types, defined as those that we can normally
  * represent directly in the output format. We hard-code that to mean
  * num, String, and bool.
  */
 class PrimitiveRule extends SerializationRule {
   appliesTo(object, Writer w) {
     return isPrimitive(object);
   }
-  extractState(object, Function f) => object;
+  extractState(object, Function f, Writer w) => object;
   flatten(object, Writer writer) {}
   inflateEssential(state, Reader r) => state;
   inflateNonEssential(object, _, Reader r) {}
 
   bool get storesStateAsPrimitives => true;
 
   /**
    * Indicate whether we should save pointers to this object as references
    * or store the object directly. For primitives this depends on the format,
    * so we delegate to the writer.
@@ skipping 59 matching lines @@
 class NamedObjectRule extends SerializationRule {
   /**
    * Return true if this rule applies to the object. Checked by looking up
    * in the namedObjects collection.
    */
   bool appliesTo(object, Writer writer) {
     return writer.hasNameFor(object);
   }
 
   /** Extract the state of the named objects as just the object itself. */
-  extractState(object, Function f) => [object];
+  extractState(object, Function f, Writer writer) {
+    var result = [nameFor(object, writer)];
+    f(result.first);
+    return result;
+  }
 
   /** When we flatten the state we save it as the name. */
   // TODO(alanknight): This seems questionable. In a truly flat format we may
   // want to have extracted the name as a string first and flatten it into a
   // reference to that. But that requires adding the Writer as a parameter to
   // extractState, and I'm reluctant to add yet another parameter until
   // proven necessary.
   flatten(state, Writer writer) {
-    state[0] = nameFor(state.first, writer);
+    state[0] = writer._referenceFor(state[0]);
   }
 
   /** Look up the named object and return it. */
-  inflateEssential(state, Reader r) => r.objectNamed(state.first);
+  inflateEssential(state, Reader r) =>
+      r.objectNamed(r.resolveReference(state.first));
 
   /** Set any non-essential state on the object. For this rule, a no-op. */
   inflateNonEssential(state, object, Reader r) {}
 
   /** Return the name for this object in the Writer. */
   nameFor(object, Writer writer) => writer.nameFor(object);
 }
 
 /**
- * This rule handles the special case of Mirrors, restricted to those that
- * have a simpleName. It knows that it applies to any such mirror and
- * automatically uses its simpleName as the key into the namedObjects.
- * When reading, the user is still responsible for adding the appropriate
- * mirrors to namedObject.
+ * This rule handles the special case of Mirrors. It stores the mirror by its
+ * qualifiedName and attempts to look it up in both the namedObjects
+ * collection, or if it's not found there, by looking it up in the mirror
+ * system. When reading, the user is responsible for supplying the appropriate
+ * values in [namedObjects] or in the [externals] paramter to
+ * [Serialization.read].
  */
 class MirrorRule extends NamedObjectRule {
   bool appliesTo(object, Writer writer) => object is DeclarationMirror;
-  nameFor(DeclarationMirror object, Writer writer) => object.simpleName;
+  nameFor(DeclarationMirror object, Writer writer) => object.qualifiedName;
+
+  inflateEssential(state, Reader r) {
+    var qualifiedName = r.resolveReference(state.first);
+    var lookupFull = r.objectNamed(qualifiedName, (x) => null);
+    if (lookupFull != null) return lookupFull;
+    var lib = qualifiedName.substring(0, qualifiedName.indexOf("."));
+    var type = qualifiedName.substring(qualifiedName.indexOf(".") + 1);
+    var lookup = r.objectNamed(type, (x) => null);
+    if (lookup != null) return lookup;
+    var libMirror = currentMirrorSystem().libraries[lib];
+    return libMirror.classes[type];
+  }
 }
 
 /**
  * This provides an abstract superclass for writing your own rules specific to
  * a class. It makes some assumptions about behaviour, and so can have a
  * simpler set of methods that need to be implemented in order to subclass it.
  *
  */
 abstract class CustomRule extends SerializationRule {
   // TODO(alanknight): It would be nice if we could provide an implementation
@@ skipping 23 matching lines @@
    */
   create(List state);
 
   /**
    * Set any state in [object] which wasn't set in the constructor. Between
    * this method and [create] all of the information in [state] should be set
    * in the new object.
    */
   void setState(object, List state);
 
-  extractState(instance, Function f) {
+  extractState(instance, Function f, Writer w) {
     var state = getState(instance);
     for (var each in values(state)) {
       f(each);
     }
     return state;
   }
 
   inflateEssential(state, Reader r) => create(_lazy(state, r));
 
-  void inflateNonEssential(state, object, Reader r) =>
-      setState(object, _lazy(state, r));
+  void inflateNonEssential(state, object, Reader r) {
+    setState(object, _lazy(state, r));
+  }
 
   // We don't want to have to make the end user tell us how long the list is
   // separately, so write it out for each object, even though they're all
   // expected to be the same length.
   get hasVariableLengthEntries => true;
 }
 
 /** Create a lazy list/map that will inflate its items on demand in [r]. */
 _lazy(l, Reader r) {
   if (l is List) return new _LazyList(l, r);
@@ skipping 85 matching lines @@
   retainAll(x) => _throw();
   removeMatching(x) => _throw();
   retainMatching(x) => _throw();
   getRange(x, y) => _throw();
   setRange(x, y, z, [a]) => _throw();
   removeRange(x, y) => _throw();
   insertRange(x, y, [z]) => _throw();
   get reversed => _throw();
   void set length(x) => _throw();
 }