anchor.diff:      Node oldNode = null;
   
       void sync(int atIndex) {
  -      if (currentNode._sync(oldNode, this, _root, nextSibling)) {
  -        // oldNode was stateful and must be retained.
  -        currentNode = oldNode;
  -        _children[atIndex] = currentNode;
  -      }
  -
  -      assert(currentNode._root is sky.Node);
  +      _children[atIndex] = _syncChild(currentNode, oldNode, _root, nextSibling);
       }
   
       // Scan backwards from end of list while nodes can be directly synced
       // without reordering.
  -    // print("...scanning backwards");
       while (endIndex > startIndex && oldEndIndex > oldStartIndex) {
         currentNode = _children[endIndex - 1];
         oldNode = oldChildren[oldEndIndex - 1];
  
positive.code:         return false;
  
        oldNodeIdMap[currentNode._key] = null; // mark it reordered.
        // print("Reparenting ${currentNode._key}");
        _parentInsertBefore(root, oldNode._root, nextSibling);
        return true;
      }
  
      // Scan forwards, this time we may re-order;
      // print("...scanning forward");
      nextSibling = root.firstChild;
      while (startIndex < endIndex && oldStartIndex < oldEndIndex) {
        currentNode = _children[startIndex];
        oldNode = oldChildren[oldStartIndex];
  
        if (currentNode._key == oldNode._key) {
          // print('> syncing matched at: $startIndex : $oldStartIndex');
          assert(currentNode.runtimeType == oldNode.runtimeType);
          nextSibling = nextSibling.nextSibling;
          sync(startIndex);
  
negative.code:     _key = key == null ? "$runtimeType" : "$runtimeType-$key";
    }
  
    // Subclasses which implements Nodes that become stateful may return true
    // if the |old| node has become stateful and should be retained.
    bool _willSync(Node old) => false;
  
    void _sync(Node old, sky.ParentNode host, sky.Node insertBefore);
  
    void _remove() {
      _defunct = true;
      _root = null;
    }
  
    // Returns the child which should be retained as the child of this node.
    Node _syncChild(Node node, Node oldNode, sky.ParentNode host,
        sky.Node insertBefore) {
      if (node == oldNode)
        return node; // Nothing to do. Subtrees must be identical.
  
      // TODO(rafaelw): This eagerly removes the old DOM. It may be that a
      // new component was built that could re-use some of it. Consider
      // syncing the new VDOM against the old one.
      if (oldNode != null && node._key != oldNode._key) {
        oldNode._remove();
      }
  
      if (node._willSync(oldNode)) {
        oldNode._sync(node, host, insertBefore);
        node._defunct = true;
        assert(oldNode._root is sky.Node);
        return oldNode;
      }
  
      node._parent = this;
      node._sync(oldNode, host, insertBefore);
      if (oldNode != null)
        oldNode._defunct = true;
  
      assert(node._root is sky.Node);
      return node;
    }
  
    void _syncEvents(EventMap oldEventMap) {
      List<EventHandler> newHandlers = events._handlers;
      int newStartIndex = 0;
      int newEndIndex = newHandlers.length;
  
      List<EventHandler> oldHandlers = oldEventMap._handlers;
      int oldStartIndex = 0;
      int oldEndIndex = oldHandlers.length;
  
  