anchor.diff:      this.minDeltaRadius: 0.0,
       this.maxDeltaRadius: double.INFINITY,
       this.minDeltaTheta: 0.0,
  -    this.maxDeltaTheta: kTwoPi});
  +    this.maxDeltaTheta: kTwoPi
  +  });
   
     const SectorConstraints.tight({ double deltaRadius: 0.0, double deltaTheta: 0.0 })
       : minDeltaRadius = deltaRadius,
  
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:   }
  
    SectorConstraints _constraints;
    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(relayoutSubtreeRoot);
    }
  
    void relayout() {
      // TODO(ianh): avoid code duplication
      assert(parentData is SectorParentData);
      internalLayout(this);
    }
  
    void internalLayout(RenderNode relayoutSubtreeRoot) {
      assert(this.parentData is SectorParentData);
      double innerDeltaRadius = deltaRadius - padding * 2.0;
      double childRadius = this.parentData.radius + padding;
      double paddingTheta = math.atan(padding / (this.parentData.radius + deltaRadius));
      double innerTheta = paddingTheta; // increments with each child
      double remainingDeltaTheta = _constraints.maxDeltaTheta - (innerTheta + paddingTheta);
      RenderSector child = firstChild;
      while (child != null) {
        SectorConstraints innerConstraints = new SectorConstraints(
          maxDeltaRadius: innerDeltaRadius,
          maxDeltaTheta: remainingDeltaTheta
        );
        assert(child.parentData is SectorParentData);
        child.parentData.theta = innerTheta;
        child.parentData.radius = childRadius;
        child.layout(innerConstraints, relayoutSubtreeRoot: relayoutSubtreeRoot);
        innerTheta += child.deltaTheta;
        remainingDeltaTheta -= child.deltaTheta;
        assert(child.parentData is SectorChildListParentData);
        child = child.parentData.nextSibling;
        if (child != null) {
          innerTheta += paddingTheta;
          remainingDeltaTheta -= paddingTheta;
        }
      }
      deltaTheta = innerTheta;
  