Remove one more use of mirrors: Components now have to explicitly sync their fields.

sky/sdk/lib/framework/fn2.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 library fn;
 
 import 'app.dart';
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 import 'package:vector_math/vector_math.dart';
-import 'reflect.dart' as reflect;
 import 'rendering/block.dart';
 import 'rendering/box.dart';
 import 'rendering/flex.dart';
 import 'rendering/object.dart';
 import 'rendering/paragraph.dart';
 import 'rendering/stack.dart';
 export 'rendering/object.dart' show Point, Size, Rect, Color, Paint, Path;
 export 'rendering/box.dart' show BoxConstraints, BoxDecoration, Border, BorderSide, EdgeDims;
 export 'rendering/flex.dart' show FlexDirection;
 
@@ skipping 58 matching lines @@
       _notifyingMountStatus = false;
     }
   }
   void _didMount() { }
   void _didUnmount() { }
 
   RenderObject root;
 
   // Subclasses which implements Nodes that become stateful may return true
   // if the |old| node has become stateful and should be retained.
-  bool _willSync(UINode old) => false;
+  // This is called immediately before _sync().
+  // Component._retainStatefulNodeIfPossible() calls syncFields().
+  bool _retainStatefulNodeIfPossible(UINode old) => false;
 
   bool get interchangeable => false; // if true, then keys can be duplicated
 
   void _sync(UINode old, dynamic slot);
   // 'slot' is the identifier that the parent RenderObjectWrapper uses to know
   // where to put this descendant
 
   void remove() {
     root = null;
     setParent(null);
@@ skipping 21 matching lines @@
     }
 
     if (node == null) {
       // the child in this slot has gone away
       assert(oldNode.mounted);
       removeChild(oldNode);
       assert(!oldNode.mounted);
       return null;
     }
 
-    if (oldNode != null && node._key == oldNode._key && node._willSync(oldNode)) {
+    if (oldNode != null && node._key == oldNode._key && node._retainStatefulNodeIfPossible(oldNode)) {
       assert(oldNode.mounted);
       assert(!node.mounted);
       oldNode._sync(node, slot);
       assert(oldNode.root is RenderObject);
       return oldNode;
     }
 
     if (oldNode != null && node._key != oldNode._key) {
       assert(oldNode.mounted);
       removeChild(oldNode);
@@ skipping 777 matching lines @@
   }
 
   void remove() {
     assert(_built != null);
     assert(root != null);
     removeChild(_built);
     _built = null;
     super.remove();
   }
 
-  bool _willSync(UINode old) {
+  bool _retainStatefulNodeIfPossible(UINode old) {
     assert(!_disqualifiedFromEverAppearingAgain);
 
     Component oldComponent = old as Component;
     if (oldComponent == null || !oldComponent._stateful)
       return false;
 
-    // Make |this| the "old" Component
+    assert(key == oldComponent.key);
+
+    // Make |this|, the newly-created object, into the "old" Component, and kill it
     _stateful = false;
     _built = oldComponent._built;
     assert(_built != null);
     _disqualifiedFromEverAppearingAgain = true;
 
     // Make |oldComponent| the "new" component
-    reflect.copyPublicFields(this, oldComponent);
     oldComponent._built = null;
     oldComponent._dirty = true;
+    oldComponent.syncFields(this);
     return true;
   }
 
+  // This is called by _retainStatefulNodeIfPossible(), during
+  // syncChild(), just before _sync() is called.
+  // This must be implemented on any subclass that can become stateful
+  // (but don't call super.syncFields() if you inherit directly from
+  // Component, since that'll fire an assert).
+  // If you don't ever become stateful, then don't override this.
+  void syncFields(Component source) {
+    assert(false);
+  }
+
   final int _order;
   static int _currentOrder = 0;
 
   /* There are three cases here:
    * 1) Building for the first time:
    *      assert(_built == null && old == null)
    * 2) Re-building (because a dirty flag got set):
    *      assert(_built != null && old == null)
    * 3) Syncing against an old version
    *      assert(_built == null && old != null)
@@ skipping 151 matching lines @@
   }
 
 }
 
 class Text extends Component {
   Text(this.data) : super(key: '*text*');
   final String data;
   bool get interchangeable => true;
   UINode build() => new Paragraph(text: data);
 }