anchor.diff:      assert(_depth == null);
       _parent = parent;
       _slot = slot;
  -    _depth = _parent != null ? _parent._depth + 1 : 0;
  +    _depth = _parent != null ? _parent._depth + 1 : 1;
       assert(() { _debugLifecycleState = _ElementLifecycle.mounted; return true; });
     }
   
  
positive.code:   }
  }
  
  RenderObjectElement _findAncestorRenderObjectElement(Element ancestor) {
    while (ancestor != null && ancestor is! RenderObjectElement)
      ancestor = ancestor._parent;
    return ancestor;
  }
  
  class RenderObjectElement<T extends RenderObjectWidget> extends Element<T> {
    RenderObjectElement(T widget)
      : renderObject = widget.createRenderObject(), super(widget);
  
    final RenderObject renderObject;
    RenderObjectElement _ancestorRenderObjectElement;
  
    void mount(Element parent, dynamic slot) {
      super.mount(parent, slot);
      assert(_ancestorRenderObjectElement == null);
      _ancestorRenderObjectElement = _findAncestorRenderObjectElement(_parent);
      if (_ancestorRenderObjectElement != null)
        _ancestorRenderObjectElement.insertChildRenderObject(renderObject, slot);
    }
  
    void update(T newWidget) {
  
negative.code:   }
  }
  
  /// Instantiation of RenderObjectWidgets that can have a list of children
  class MultiChildRenderObjectElement<T extends MultiChildRenderObjectWidget> extends RenderObjectElement<T> {
    MultiChildRenderObjectElement(T widget) : super(widget);
  
    // TODO(ianh): implement
  }
  
  class _BuildScheduler {
    final List<BuildableElement> _dirtyElements = new List<BuildableElement>();
  
    int _debugBuildingAtDepth;
  
    void schedule(BuildableElement element) {
      assert(_debugBuildingAtDepth == null || element._depth > _debugBuildingAtDepth);
      assert(!_dirtyElements.contains(element));
      if (_dirtyElements.isEmpty)
        scheduler.ensureVisualUpdate();
      _dirtyElements.add(element);
    }
  
    void _absorbDirtyElements(List<BuildableElement> list) {
      assert(_debugBuildingAtDepth != null);
      assert(!_dirtyElements.any((element) => element._depth <= _debugBuildingAtDepth));
      _dirtyElements.sort((BuildableElement a, BuildableElement b) => a._depth - b._depth);
      list.addAll(_dirtyElements);
      _dirtyElements.clear();
    }
  
    /// Builds all the elements that were marked as dirty using schedule(), in depth order.
    /// If elements are marked as dirty while this runs, they must be deeper than the algorithm
    /// has yet reached.
    void buildDirtyElements() {
      assert(_debugBuildingAtDepth == null);
      if (_dirtyElements.isEmpty)
        return;
      assert(() { _debugBuildingAtDepth = 0; return true; });
      List<BuildableElement> sortedDirtyElements = new List<BuildableElement>();
      int index = 0;
      do {
        _absorbDirtyElements(sortedDirtyElements);
        for (; index < sortedDirtyElements.length; index += 1) {
          BuildableElement element = sortedDirtyElements[index];
          assert(() {
            if (element._depth > _debugBuildingAtDepth)
              _debugBuildingAtDepth = element._depth;
            return element._depth == _debugBuildingAtDepth;
          });
          element._rebuildIfNeeded();
        }
      } while (_dirtyElements.isNotEmpty);
      assert(() { _debugBuildingAtDepth = null; return true; });
    }
  }
  
  final _BuildScheduler _buildScheduler = new _BuildScheduler();
  
  
  typedef void WidgetsExceptionHandler(String context, dynamic exception, StackTrace stack);
  