anchor.diff:  
   class BlockParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> { }
   
  +enum BlockDirection { horizontal, vertical }
  +
  +typedef double _ChildSizingFunction(RenderBox child, BoxConstraints constraints);
  +
   abstract class RenderBlockBase extends RenderBox with ContainerRenderObjectMixin<RenderBox, BlockParentData>,
                                                         RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
   
  
positive.code:       child.parentData = new BlockParentData();
    }
  
    double _childrenHeight;
    double get childrenHeight => _childrenHeight;
  
    void markNeedsLayout() {
      _childrenHeight = null;
      super.markNeedsLayout();
    }
  
    void performLayout() {
      assert(constraints is BoxConstraints);
      double width = constraints.constrainWidth(constraints.maxWidth);
      BoxConstraints innerConstraints = new BoxConstraints.tightFor(width: width);
      double y = 0.0;
      RenderBox child = firstChild;
      while (child != null) {
        child.layout(innerConstraints, parentUsesSize: true);
        assert(child.parentData is BlockParentData);
        child.parentData.position = new Point(0.0, y);
        y += child.size.height;
        child = child.parentData.nextSibling;
      }
      _childrenHeight = y;
    }
  
  }
  
  class RenderBlock extends RenderBlockBase {
  
    // sizes itself to the height of its child stack
  
    RenderBlock({ List<RenderBox> children }) : super(children: children);
  
    double getMinIntrinsicWidth(BoxConstraints constraints) {
      double width = 0.0;
      BoxConstraints innerConstraints = constraints.widthConstraints();
      RenderBox child = firstChild;
      while (child != null) {
        width = math.max(width, child.getMinIntrinsicWidth(innerConstraints));
        assert(child.parentData is BlockParentData);
        child = child.parentData.nextSibling;
      }
      return width;
    }
  
    double getMaxIntrinsicWidth(BoxConstraints constraints) {
      double width = 0.0;
      BoxConstraints innerConstraints = constraints.widthConstraints();
      RenderBox child = firstChild;
      while (child != null) {
        width = math.max(width, child.getMaxIntrinsicWidth(innerConstraints));
        assert(child.parentData is BlockParentData);
        child = child.parentData.nextSibling;
      }
      return width;
    }
  
    double _getIntrinsicHeight(BoxConstraints constraints) {
      double height = 0.0;
      double width = constraints.constrainWidth(constraints.maxWidth);
      BoxConstraints innerConstraints = new BoxConstraints.tightFor(width: width);
      RenderBox child = firstChild;
      while (child != null) {
        double childHeight = child.getMinIntrinsicHeight(innerConstraints);
        assert(childHeight == child.getMaxIntrinsicHeight(innerConstraints));
        height += childHeight;
        assert(child.parentData is BlockParentData);
        child = child.parentData.nextSibling;
      }
      return height;
    }
  
    double getMinIntrinsicHeight(BoxConstraints constraints) {
      return _getIntrinsicHeight(constraints);
    }
  
    double getMaxIntrinsicHeight(BoxConstraints constraints) {
      return _getIntrinsicHeight(constraints);
    }
  
    double computeDistanceToActualBaseline(TextBaseline baseline) {
      return defaultComputeDistanceToFirstActualBaseline(baseline);
    }
  
    void performLayout() {
      assert(constraints.maxHeight >= double.INFINITY);
      super.performLayout();
      size = constraints.constrain(new Size(constraints.maxWidth, childrenHeight));
      assert(!size.isInfinite);
    }
  
  
negative.code:   // uses the maximum width provided by the parent
  
    RenderBlockBase({
      List<RenderBox> children,
      BlockDirection direction: BlockDirection.vertical
    }) : _direction = direction {
      addAll(children);
    }
  
  