When syncing a child, we have to update the parent in all cases.

sky/sdk/lib/widgets/widget.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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 
 import '../base/hit_test.dart';
@@ skipping 49 matching lines @@
       }
     } else {
       assert(newParent._mounted);
       if (_parent._mounted != _mounted) {
         _mounted = _parent._mounted;
         _mountedChanged.add(this);
       }
     }
   }
 
-  // Override this if you have children and call walker on each child
+  // Override this if you have children and call walker on each child.
+  // Note that you may be called before the child has had its parent
+  // pointer set to point to you. Your walker, and any methods it
+  // invokes on your descendants, should not rely on the ancestor
+  // chain being correctly configured at this point.
   void walkChildren(WidgetTreeWalker walker) { }
 
   static void _notifyMountStatusChanged() {
     try {
       sky.tracing.begin("Widget._notifyMountStatusChanged");
       _notifyingMountStatus = true;
       for (Widget node in _mountedChanged) {
         if (node._wasMounted != node._mounted) {
           if (node._mounted)
             node.didMount();
@@ skipping 30 matching lines @@
       ancestor = ancestor._parent;
     return ancestor;
   }
 
   void remove() {
     _root = null;
     setParent(null);
   }
 
   void removeChild(Widget node) {
+    // Call this when we no longer have a child equivalent to node.
+    // For example, when our child has changed type, or has been set to null.
+    // Do not call this when our child has been replaced by an equivalent but
+    // newer instance that will sync() with the old one, since in that case
+    // the subtree starting from the old node, as well as the render tree that
+    // belonged to the old node, continue to live on in the replacement node.
     node.remove();
+    assert(node.parent == null);
   }
 
   void detachRoot();
 
   // Returns the child which should be retained as the child of this node.
   Widget syncChild(Widget newNode, Widget oldNode, dynamic slot) {
 
     assert(oldNode is! Component ||
            (oldNode is Component && !oldNode._disqualifiedFromEverAppearingAgain)); // TODO(ianh): Simplify this once the analyzer is cleverer
 
     if (newNode == oldNode) {
       assert(newNode == null || newNode.mounted);
       assert(newNode is! RenderObjectWrapper ||
              (newNode is RenderObjectWrapper && newNode._ancestor != null)); // TODO(ianh): Simplify this once the analyzer is cleverer
+      if (newNode != null)
+        newNode.setParent(this);
       return newNode; // Nothing to do. Subtrees must be identical.
     }
 
     if (newNode == null) {
       // the child in this slot has gone away
       assert(oldNode.mounted);
       oldNode.detachRoot();
       removeChild(oldNode);
       assert(!oldNode.mounted);
       return null;
     }
 
     if (oldNode != null) {
       if (oldNode.runtimeType == newNode.runtimeType && oldNode.key == newNode.key) {
         if (newNode._retainStatefulNodeIfPossible(oldNode)) {
           assert(oldNode.mounted);
           assert(!newNode.mounted);
           oldNode.setParent(this);
           oldNode._sync(newNode, slot);
           assert(oldNode.root is RenderObject);
           return oldNode;
+        } else {
+          oldNode.setParent(null);
         }
       } else {
         assert(oldNode.mounted);
         oldNode.detachRoot();
         removeChild(oldNode);
         oldNode = null;
       }
     }
 
+    assert(oldNode == null || (oldNode.mounted == false && oldNode.parent == null));
     assert(!newNode.mounted);
     newNode.setParent(this);
     newNode._sync(oldNode, slot);
     assert(newNode.root is RenderObject);
     return newNode;
   }
 
   String toString() {
     if (key == null)
       return '$runtimeType(unkeyed)';
@@ skipping 17 matching lines @@
 
   Widget child;
 
   void walkChildren(WidgetTreeWalker walker) {
     walker(child);
   }
 
   void _sync(Widget old, dynamic slot) {
     Widget oldChild = old == null ? null : (old as TagNode).child;
     child = syncChild(child, oldChild, slot);
+    assert(child.parent == this);
     assert(child.root != null);
     _root = child.root;
     assert(_root == root); // in case a subclass reintroduces it
   }
 
   void remove() {
     if (child != null)
       removeChild(child);
     super.remove();
   }
@@ skipping 242 matching lines @@
     int lastOrder = _currentOrder;
     _currentOrder = _order;
     _currentlyBuilding = this;
     _built = build();
     assert(_built != null);
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
     _built = syncChild(_built, oldBuilt, slot);
     assert(_built != null);
+    assert(_built.parent == this);
     _dirty = false;
     _root = _built.root;
     assert(_root == root); // in case a subclass reintroduces it
     assert(root != null);
   }
 
   void _buildIfDirty() {
     assert(!_disqualifiedFromEverAppearingAgain);
     if (!_dirty || !_mounted)
       return;
@@ skipping 181 matching lines @@
   Widget _child;
   Widget get child => _child;
 
   void walkChildren(WidgetTreeWalker walker) {
     walker(child);
   }
 
   void syncRenderObject(RenderObjectWrapper old) {
     super.syncRenderObject(old);
     Widget oldChild = old == null ? null : (old as OneChildRenderObjectWrapper).child;
-    _child = syncChild(child, oldChild, null);
+    Widget newChild = child;
+    _child = syncChild(newChild, oldChild, null);
+    assert((newChild == null && child == null) || (newChild != null && child.parent == this));
+    assert(oldChild == null || child == oldChild || oldChild.parent == null);
   }
 
   void insertChildRoot(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is RenderObjectWithChildMixin);
     assert(slot == null);
     root.child = child.root;
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
@@ skipping 19 matching lines @@
 
   MultiChildRenderObjectWrapper({ String key, List<Widget> children })
     : this.children = children == null ? const [] : children,
       super(key: key) {
     assert(!_debugHasDuplicateIds());
   }
 
   final List<Widget> children;
 
   void walkChildren(WidgetTreeWalker walker) {
-    for(Widget child in children)
+    for (Widget child in children)
       walker(child);
   }
 
   void insertChildRoot(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(slot == null || slot is RenderObject);
     assert(root is ContainerRenderObjectMixin);
     root.add(child.root, before: slot);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
@@ skipping 43 matching lines @@
     var oldStartIndex = 0;
     var oldEndIndex = oldChildren.length;
 
     RenderObject nextSibling = null;
     Widget currentNode = null;
     Widget oldNode = null;
 
     void sync(int atIndex) {
       children[atIndex] = syncChild(currentNode, oldNode, nextSibling);
       assert(children[atIndex] != null);
+      assert(children[atIndex].parent == this);
     }
 
     // Scan backwards from end of list while nodes can be directly synced
     // without reordering.
     while (endIndex > startIndex && oldEndIndex > oldStartIndex) {
       currentNode = children[endIndex - 1];
       oldNode = oldChildren[oldEndIndex - 1];
 
       if (currentNode.runtimeType != oldNode.runtimeType || currentNode.key != oldNode.key) {
         break;
@@ skipping 83 matching lines @@
       currentNode = children[startIndex];
       sync(startIndex);
       startIndex++;
     }
 
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       syncChild(null, oldNode, null);
+      assert(oldNode.parent == null);
       advanceOldStartIndex();
     }
 
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
 }
 
 class WidgetSkyBinding extends SkyBinding {
 
@@ skipping 128 matching lines @@
     if (root.parent == null) {
       // we haven't attached it yet
       assert(_container.child == null);
       _container.child = root;
     }
     assert(root.parent == _container);
   }
 
   Widget build() => builder();
 }