anchor.diff:      assert(parent != null || this is RenderViewWrapper);
       if (old == null) {
         _root = createNode();
  +      assert(_root != null);
         _ancestor = findAncestorRenderObjectWrapper();
         if (_ancestor is RenderObjectWrapper)
           _ancestor.insertChildRoot(this, slot);
  
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:   RenderObject get root => _root;
  
    // Subclasses which implements Nodes that become stateful may return true
    // if the node has become stateful and should be retained.
    // This is called immediately before _sync().
    // Component.retainStatefulNodeIfPossible() calls syncFields().
    bool retainStatefulNodeIfPossible(Widget newNode) => false;
  
    void _sync(Widget old, dynamic slot);
    void updateSlot(dynamic newSlot);
  