anchor.diff:    void unmount() {
       assert(_debugLifecycleState == _ElementLifecycle.mounted);
       assert(_widget != null);
  -    assert(_slot == null);
       assert(_depth != null);
       assert(() { _debugLifecycleState = _ElementLifecycle.defunct; return true; });
     }
   
  +  // TODO(ianh): Merge this into the binding, expose for tests
     static void flushBuild() {
       _buildScheduler.buildDirtyElements();
     }
   }
   
  -class _BuildScheduler {
  -  final Set<BuildableElement> _dirtyElements = new Set<BuildableElement>();
  -  bool _inBuildDirtyElements = false;
  -
  -  void schedule(BuildableElement element) {
  -    if (_dirtyElements.isEmpty)
  -      scheduler.ensureVisualUpdate();
  -    _dirtyElements.add(element);
  -  }
  -
  -  void _absorbDirtyElements(List<BuildableElement> list) {
  -    list.addAll(_dirtyElements);
  -    _dirtyElements.clear();
  -    list.sort((BuildableElement a, BuildableElement b) => a._depth - b._depth);
  -  }
  -
  -  void buildDirtyElements() {
  -    if (_dirtyElements.isEmpty)
  -      return;
  -
  -    _inBuildDirtyElements = true;
  -    try {
  -      while (!_dirtyElements.isEmpty) {
  -        List<BuildableElement> sortedDirtyElements = new List<BuildableElement>();
  -        _absorbDirtyElements(sortedDirtyElements);
  -        int index = 0;
  -        while (index < sortedDirtyElements.length) {
  -          sortedDirtyElements[index]._rebuildIfNeeded();
  -          if (!_dirtyElements.isEmpty) {
  -            assert(_dirtyElements.every((Element element) => !sortedDirtyElements.contains(element)));
  -            _absorbDirtyElements(sortedDirtyElements);
  -            index = 0;
  -          } else {
  -            index += 1;
  -          }
  -        }
  -      }
  -    } finally {
  -      _inBuildDirtyElements = false;
  -    }
  -    assert(_dirtyElements.isEmpty);
  -  }
  -}
  -
  -final _BuildScheduler _buildScheduler = new _BuildScheduler();
  -
   typedef Widget WidgetBuilder();
   
  +/// Base class for the instantiation of StatelessComponent and StatefulComponent
  +/// widgets.
   abstract class BuildableElement<T extends Widget> extends Element<T> {
     BuildableElement(T widget) : super(widget);
   
  
positive.code:   }
  }
  
  class MultiChildRenderObjectElement<T extends MultiChildRenderObjectWidget> extends RenderObjectElement<T> {
    MultiChildRenderObjectElement(T widget) : super(widget);
  }
  
  
  
  typedef void WidgetsExceptionHandler(String context, dynamic exception, StackTrace stack);
  
negative.code:     _child = _updateChild(_child, built, _slot);
    }
  
    /// Called by the binding when scheduleBuild() has been called to mark this element dirty.
    void _rebuildIfNeeded() {
      if (_dirty)
        _rebuild();
    }
  
    /// Marks the element as dirty and adds it to the global list of widgets to
    /// rebuild in the next frame.
    ///
    /// Since it is inefficient to build an element twice in one frame,
    /// applications and components should be structured so as to only mark
    /// components dirty during event handlers before the frame begins, not during
    /// the build itself.
    void scheduleBuild() {
      assert(_debugLifecycleState == _ElementLifecycle.mounted);
      if (_dirty)
        return;
      _dirty = true;
      _buildScheduler.schedule(this);
    }
  
    void visitChildren(ElementVisitor visitor) {
  