anchor.diff:    }
   
     SectorConstraints _constraints;
  -  void layout(SectorConstraints constraints, double radius, { RenderNode relayoutSubtreeRoot }) {
  +  void layout(SectorConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
       if (relayoutSubtreeRoot != null)
         saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
       relayoutSubtreeRoot = relayoutSubtreeRoot == null ? this : relayoutSubtreeRoot;
       deltaRadius = constraints.constrainDeltaRadius(desiredDeltaRadius);
       assert(deltaRadius < double.INFINITY);
       _constraints = constraints;
  -    internalLayout(radius, relayoutSubtreeRoot);
  +    internalLayout(relayoutSubtreeRoot);
     }
   
     void relayout() {
  +    // TODO(ianh): avoid code duplication
       assert(parentData is SectorParentData);
  -    internalLayout(parentData.radius, this);
  -  }
  -
  -  void internalLayout(double radius, RenderNode relayoutSubtreeRoot) {
  +    internalLayout(this);
  +  }
  +
  +  void internalLayout(RenderNode relayoutSubtreeRoot) {
  +    assert(this.parentData is SectorParentData);
       double innerDeltaRadius = deltaRadius - padding * 2.0;
  -    double childRadius = radius + padding;
  -    double paddingTheta = math.atan(padding / (radius + deltaRadius));
  +    double childRadius = this.parentData.radius + padding;
  +    double paddingTheta = math.atan(padding / (this.parentData.radius + deltaRadius));
       double innerTheta = paddingTheta; // increments with each child
  -    double remainingTheta = _constraints.maxDeltaTheta - (innerTheta + paddingTheta);
  +    double remainingDeltaTheta = _constraints.maxDeltaTheta - (innerTheta + paddingTheta);
       RenderSector child = firstChild;
       while (child != null) {
         SectorConstraints innerConstraints = new SectorConstraints(
           maxDeltaRadius: innerDeltaRadius,
  -        maxDeltaTheta: remainingTheta
  +        maxDeltaTheta: remainingDeltaTheta
         );
  -      child.layout(innerConstraints, childRadius, relayoutSubtreeRoot: relayoutSubtreeRoot);
         assert(child.parentData is SectorParentData);
         child.parentData.theta = innerTheta;
         child.parentData.radius = childRadius;
  +      child.layout(innerConstraints, relayoutSubtreeRoot: relayoutSubtreeRoot);
         innerTheta += child.deltaTheta;
  -      remainingTheta -= child.deltaTheta;
  +      remainingDeltaTheta -= child.deltaTheta;
         assert(child.parentData is SectorChildListParentData);
         child = child.parentData.nextSibling;
         if (child != null) {
           innerTheta += paddingTheta;
  -        remainingTheta -= paddingTheta;
  +        remainingDeltaTheta -= paddingTheta;
         }
       }
       deltaTheta = innerTheta;
  
positive.code:     double childRadius = radius + padding;
      double paddingTheta = math.atan(padding / (radius + outerDeltaRadius));
      double innerTheta = paddingTheta; // increments with each child
      double remainingTheta = constraints.maxDeltaTheta - (innerTheta + paddingTheta);
      RenderSector child = firstChild;
      while (child != null) {
        SectorConstraints innerConstraints = new SectorConstraints(
          maxDeltaRadius: innerDeltaRadius,
          maxDeltaTheta: remainingTheta
        );
        SectorDimensions childDimensions = child.getIntrinsicDimensions(innerConstraints, childRadius);
        innerTheta += childDimensions.deltaTheta;
        remainingTheta -= childDimensions.deltaTheta;
        assert(child.parentData is SectorChildListParentData);
        child = child.parentData.nextSibling;
        if (child != null) {
          innerTheta += paddingTheta;
          remainingTheta -= paddingTheta;
        }
      }
      return new SectorDimensions.withConstraints(constraints,
  
negative.code:       ourDimensions = new BoxDimensions.withConstraints(constraints, width: 0.0, height: 0.0);
      } else {
        assert(child is RenderSector);
        assert(!constraints.isInfinite);
        double maxChildDeltaRadius = math.min(constraints.maxWidth, constraints.maxHeight) / 2.0 - innerRadius;
        assert(child.parentData is SectorParentData);
        child.parentData.radius = innerRadius;
        child.parentData.theta = 0.0;
        child.layout(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), relayoutSubtreeRoot: relayoutSubtreeRoot);
        double dimension = (innerRadius + child.deltaRadius) * 2.0;
        ourDimensions = new BoxDimensions.withConstraints(constraints, width: dimension, height: dimension);
      }
      width = ourDimensions.width;
      height = ourDimensions.height;
      layoutDone();
    }
  
  