anchor.diff:        assert(old is RenderObjectWrapper);
         _root = old.root;
         _ancestor = old._ancestor;
  +      assert(_root != null);
       }
       assert(_root == root); // in case a subclass reintroduces it
       assert(root != null);
  
positive.code:     return super.syncChild(node, oldNode, slot);
    }
  
    bool _retainStatefulNodeIfPossible(StatefulComponent old) {
      assert(!_disqualifiedFromEverAppearingAgain);
  
      if (old == null)
        return false;
  
      assert(runtimeType == old.runtimeType);
      assert(key == old.key);
  
      // Make |this|, the newly-created object, into the "old" Component, and kill it
      _built = old._built;
      assert(_built != null);
      _disqualifiedFromEverAppearingAgain = true;
  
      // Make |old| the "new" component
      old._built = null;
      old._dirty = true;
      old.syncFields(this);
      return true;
    }
  
    // This is called by _retainStatefulNodeIfPossible(), during
    // syncChild(), just before _sync() is called. Derived
    // classes should override this method to update `this` to
    // account for the new values the parent passed to `source`.
  
negative.code: 
      if (oldNode != null) {
        if (oldNode.runtimeType == newNode.runtimeType && oldNode.key == newNode.key) {
          if (oldNode.retainStatefulNodeIfPossible(newNode)) {
            assert(oldNode.mounted);
            assert(!newNode.mounted);
            oldNode.setParent(this);
  