Update pkg/serialization to use Symbols and synchronous mirrors

pkg/serialization/test/serialization_test.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.
 
 library serialization_test;
 
 import 'dart:json' as json;
 import 'package:unittest/unittest.dart';
 import 'package:serialization/serialization.dart';
 import 'package:serialization/src/serialization_helpers.dart';
@@ skipping 105 matching lines @@
 
   test('Stream', () {
     // This is an interesting case. The Stream doesn't expose its internal
     // collection at all, and sets it in the constructor. So to get it we
     // read a private field and then set that via the constructor. That works
     // but should we have some kind of large red flag that you're using private
     // state.
     var stream = new Stream([3,4,5]);
     expect((stream..next()).next(), 4);
     expect(stream.position, 2);
+    // The Symbol class does not allow us to create symbols for private
+    // variables. However, the mirror system uses them. So we get the symbol
+    // we want from the mirror.
+    // TODO(alanknight): Either delete this test and decide we shouldn't
+    // attempt to access private variables or fix this properly.
+    var _collectionSym = reflect(stream).type.variables.keys.firstWhere(
+        (x) => MirrorSystem.getName(x) == "_collection");
     var s = new Serialization()
       ..addRuleFor(stream,
-          constructorFields: ['_collection']);
+          constructorFields: [_collectionSym]);
     var state = states(stream, s).first;
     // Define names for the variable offsets to make this more readable.
     var _collection = 0, position = 1;
     expect(state[_collection],[3,4,5]);
     expect(state[position], 2);
   });
 
   test('date', () {
     var date = new DateTime.now();
     var s = new Serialization()
@@ skipping 65 matching lines @@
     expect(all.contains(n2), isTrue);
     expect(all.contains(n3), isTrue);
     expect(all.contains(n1.children), isTrue);
   });
 
   test('Flatten references in a cyclical structure', () {
     var s = new Serialization();
     var w = new Writer(s);
     w.trace = new Trace(w);
     w.write(n1);
-    expect(w.states.length, 5); // prims, lists, essential lists, basic
+    expect(w.states.length, 6); // prims, lists, essential lists, basic, symbol
     var children = 0, name = 1, parent = 2;
     var nodeRule = s.rules.firstWhere((x) => x is BasicRule);
     List rootNode = w.states[nodeRule.number].where(
         (x) => x[name] == "1").toList();
     rootNode = rootNode.first;
     expect(rootNode[parent], isNull);
     var list = w.states[1].first;
     expect(w.stateForReference(rootNode[children]), list);
     var parentNode = w.stateForReference(list[0])[parent];
     expect(w.stateForReference(parentNode), rootNode);
@@ skipping 514 matching lines @@
   }
   findValue(String key, Map state) {
     var answer;
     for (var each in state.keys) {
       var value = state[each];
       if (value == key) return each;
     }
     return null;
   }
 }