anchor.diff:        markNeedsLayout();
     }
   
  +  double getMinIntrinsicWidth(BoxConstraints constraints) {
  +    return constraints.constrainWidth();
  +  }
  +
  +  double getMaxIntrinsicWidth(BoxConstraints constraints) {
  +    return constraints.constrainWidth();
  +  }
  +
  +  double getMinIntrinsicHeight(BoxConstraints constraints) {
  +    return constraints.constrainHeight();
  +  }
  +
  +  double getMaxIntrinsicHeight(BoxConstraints constraints) {
  +    return constraints.constrainHeight();
  +  }
  +
     bool get sizedByParent => true;
   
     void performResize() {
  
positive.code:     return width;
    }
  
    BoxConstraints _getInnerConstraintsForWidth(double width) {
      return new BoxConstraints(minWidth: width, maxWidth: width);
    }
  
    double _getIntrinsicHeight(BoxConstraints constraints) {
      double height = 0.0;
      double width = constraints.constrainWidth(constraints.maxWidth);
      BoxConstraints innerConstraints = _getInnerConstraintsForWidth(width);
      RenderBox child = firstChild;
      while (child != null) {
        double childHeight = child.getMinIntrinsicHeight(innerConstraints);
  
negative.code:       child.parentData = new BlockParentData();
    }
  
    double computeDistanceToActualBaseline(TextBaseline baseline) {
      return defaultComputeDistanceToFirstActualBaseline(baseline);
    }
  
    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;
    }
  
    void hitTestChildren(HitTestResult result, { Point position }) {
      defaultHitTestChildren(result, position: position);
    }
  
    void paint(PaintingCanvas canvas, Offset offset) {
      defaultPaint(canvas, offset);
    }
  
  }
  
  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();
  