Fix spinning_mixed.dart, and resulting yak shave.

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 88 matching lines @@
   RenderObject _root;
   RenderObject get root => _root;
 
   // Subclasses which implements Nodes that become stateful may return true
   // if the |old| node has become stateful and should be retained.
   // This is called immediately before _sync().
   // Component._retainStatefulNodeIfPossible() calls syncFields().
   bool _retainStatefulNodeIfPossible(Widget old) => false;
 
   void _sync(Widget old, dynamic slot);
-  // 'slot' is the identifier that the parent RenderObjectWrapper uses to know
-  // where to put this descendant
+  void updateSlot(dynamic newSlot);
+  // 'slot' is the identifier that the ancestor RenderObjectWrapper uses to know
+  // where to put this descendant. If you just defer to a child, then make sure
+  // to pass them the slot.
 
   Widget findAncestor(Type targetType) {
     var ancestor = _parent;
     while (ancestor != null && !reflectClass(ancestor.runtimeType).isSubtypeOf(reflectClass(targetType)))
       ancestor = ancestor._parent;
     return ancestor;
   }
 
   void remove() {
     _root = null;
@@ skipping 58 matching lines @@
     }
 
     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() {
+  String toString([String prefix = '', String startPrefix = '']) {
+    String childrenString = '';
+    List<Widget> children = new List<Widget>();
+    walkChildren(children.add);
+    if (children.length > 0) {
+      Widget lastChild = children.removeLast();
+      String nextStartPrefix = prefix + ' +-';
+      String nextPrefix = prefix + ' | ';
+      for (Widget child in children)
+        childrenString += child.toString(nextPrefix, nextStartPrefix);
+      String lastStartPrefix = prefix + ' \'-';
+      String lastPrefix = prefix + '   ';
+      childrenString += lastChild.toString(lastPrefix, lastStartPrefix);
+    }
     if (key == null)
-      return '$runtimeType(unkeyed)';
-    return '$runtimeType("$key")';
+      return '$startPrefix$runtimeType(unkeyed)\n$childrenString';
+    return '$startPrefix$runtimeType("$key")\n$childrenString';
   }
 
 }
 
 
 // Descendants of TagNode provide a way to tag RenderObjectWrapper and
 // Component nodes with annotations, such as event listeners,
 // stylistic information, etc.
 abstract class TagNode extends Widget {
 
   TagNode(Widget child, { String key })
     : this.child = child, super(key: key);
 
   // TODO(jackson): Remove this workaround for limitation of Dart mixins
   TagNode._withKey(Widget child, String key)
     : this.child = child, super._withKey(key);
 
   Widget child;
 
   void walkChildren(WidgetTreeWalker walker) {
-    walker(child);
+    if (child != null)
+      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 updateSlot(dynamic newSlot) {
+    child.updateSlot(newSlot);
+  }
+
   void remove() {
     if (child != null)
       removeChild(child);
     super.remove();
   }
 
   void detachRoot() {
     if (child != null)
       child.detachRoot();
   }
@@ skipping 132 matching lines @@
   static Component _currentlyBuilding;
   bool get _isBuilding => _currentlyBuilding == this;
 
   bool _stateful;
   bool _dirty = true;
   bool _disqualifiedFromEverAppearingAgain = false;
 
   Widget _built;
   dynamic _slot; // cached slot from the last time we were synced
 
+  void updateSlot(dynamic newSlot) {
+    _slot = newSlot;
+    if (_built != null)
+      _built.updateSlot(newSlot);
+  }
+
+  void walkChildren(WidgetTreeWalker walker) {
+    if (_built != null)
+      walker(_built);
+  }
+
   void didMount() {
     assert(!_disqualifiedFromEverAppearingAgain);
     super.didMount();
   }
 
   void remove() {
     assert(_built != null);
     assert(root != null);
     removeChild(_built);
     _built = null;
@@ skipping 65 matching lines @@
   // 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)
   void _sync(Component old, dynamic slot) {
     assert(_built == null || old == null);
     assert(!_disqualifiedFromEverAppearingAgain);
 
-    _slot = slot;
+    updateSlot(slot);
 
     var oldBuilt;
     if (old == null) {
       oldBuilt = _built;
     } else {
       assert(_built == null);
       oldBuilt = old._built;
     }
 
     int lastOrder = _currentOrder;
@@ skipping 10 matching lines @@
     _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;
-
     assert(root != null);
     _sync(null, _slot);
   }
 
   void scheduleBuild() {
     assert(!_disqualifiedFromEverAppearingAgain);
     if (_isBuilding || _dirty || !_mounted)
       return;
     _dirty = true;
     _scheduleComponentForRender(this);
@@ skipping 107 matching lines @@
       _root = old.root;
       _ancestor = old._ancestor;
     }
     assert(_root == root); // in case a subclass reintroduces it
     assert(root != null);
     assert(mounted);
     _nodeMap[root] = this;
     syncRenderObject(old);
   }
 
+  void updateSlot(dynamic newSlot) {
+    // We never use the slot except during sync(), in which
+    // case our parent is handing it to us anyway.
+    // We don't need to propagate this to our children, since
+    // we give them their own slots for them to fit into us.
+  }
+
   void syncRenderObject(RenderObjectWrapper old) {
     ParentData parentData = null;
     Widget ancestor = parent;
     while (ancestor != null && ancestor is! RenderObjectWrapper) {
       if (ancestor is ParentDataNode && ancestor.parentData != null) {
         if (parentData != null)
           parentData.merge(ancestor.parentData); // this will throw if the types aren't the same
         else
           parentData = ancestor.parentData;
       }
@@ skipping 37 matching lines @@
 
 abstract class OneChildRenderObjectWrapper extends RenderObjectWrapper {
 
   OneChildRenderObjectWrapper({ String key, Widget child })
     : _child = child, super(key: key);
 
   Widget _child;
   Widget get child => _child;
 
   void walkChildren(WidgetTreeWalker walker) {
-    walker(child);
+    if (child != null)
+      walker(child);
   }
 
   void syncRenderObject(RenderObjectWrapper old) {
     super.syncRenderObject(old);
     Widget oldChild = old == null ? null : (old as OneChildRenderObjectWrapper).child;
     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);
   }
@@ skipping 93 matching lines @@
     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);
+      if (atIndex > 0)
+        children[atIndex-1].updateSlot(children[atIndex].root);
     }
 
     // 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 232 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();
 }