anchor.diff:      super.syncRenderObject(old);
       root.additionalConstraints = _additionalConstraints();
     }
  -
   }
   
   class ConstrainedBox extends OneChildRenderObjectWrapper {
  -
     ConstrainedBox({ String key, this.constraints, Widget child })
       : super(key: key, child: child);
   
  +  final BoxConstraints constraints;
  +
  +  RenderConstrainedBox createNode() => new RenderConstrainedBox(additionalConstraints: constraints);
     RenderConstrainedBox get root => super.root;
   
  -  final BoxConstraints constraints;
  -
  -  RenderConstrainedBox createNode() => new RenderConstrainedBox(additionalConstraints: constraints);
  -
     void syncRenderObject(ConstrainedBox old) {
       super.syncRenderObject(old);
       root.additionalConstraints = constraints;
     }
  -
   }
   
   class ShrinkWrapWidth extends OneChildRenderObjectWrapper {
  -
  -  ShrinkWrapWidth({
  -    String key,
  -    this.stepWidth,
  -    this.stepHeight,
  -    Widget child
  -  }): super(key: key, child: child);
  -
  -  RenderShrinkWrapWidth get root => super.root;
  +  ShrinkWrapWidth({ String key, this.stepWidth, this.stepHeight, Widget child })
  +    : super(key: key, child: child);
   
     final double stepWidth;
     final double stepHeight;
   
     RenderShrinkWrapWidth createNode() => new RenderShrinkWrapWidth();
  +  RenderShrinkWrapWidth get root => super.root;
   
     void syncRenderObject(ShrinkWrapWidth old) {
       super.syncRenderObject(old);
       root.stepWidth = stepWidth;
       root.stepHeight = stepHeight;
     }
  -
   }
   
   class Baseline extends OneChildRenderObjectWrapper {
  -
  -  Baseline({
  -    String key,
  -    this.baseline, // in pixels
  -    this.baselineType: TextBaseline.alphabetic,
  -    Widget child
  -  }): super(key: key, child: child);
  -
  +  Baseline({ String key, this.baseline, this.baselineType: TextBaseline.alphabetic, Widget child })
  +    : super(key: key, child: child);
  +
  +  final double baseline; // in pixels
  +  final TextBaseline baselineType;
  +
  +  RenderBaseline createNode() => new RenderBaseline(baseline: baseline, baselineType: baselineType);
     RenderBaseline get root => super.root;
  -
  -  final double baseline;
  -  final TextBaseline baselineType;
  -
  -  RenderBaseline createNode() => new RenderBaseline(baseline: baseline, baselineType: baselineType);
   
     void syncRenderObject(Baseline old) {
       super.syncRenderObject(old);
       root.baseline = baseline;
       root.baselineType = baselineType;
     }
  -
   }
   
   class Viewport extends OneChildRenderObjectWrapper {
  -
  -  Viewport({
  -    String key,
  -    this.offset: 0.0,
  -    Widget child
  -  }) : super(key: key, child: child);
  +  Viewport({ String key, this.offset: 0.0, Widget child })
  +    : super(key: key, child: child);
   
     final double offset;
   
  +  RenderViewport createNode() => new RenderViewport(scrollOffset: new Offset(0.0, offset));
     RenderViewport get root => super.root;
  -  RenderViewport createNode() => new RenderViewport(scrollOffset: new Offset(0.0, offset));
   
     void syncRenderObject(Viewport old) {
       super.syncRenderObject(old);
       root.scrollOffset = new Offset(0.0, offset);
     }
  -
   }
   
   class SizeObserver extends OneChildRenderObjectWrapper {
  -
     SizeObserver({ String key, this.callback, Widget child })
       : super(key: key, child: child);
   
  +  final SizeChangedCallback callback;
  +
  +  RenderSizeObserver createNode() => new RenderSizeObserver(callback: callback);
     RenderSizeObserver get root => super.root;
  -  final SizeChangedCallback callback;
  -
  -  RenderSizeObserver createNode() => new RenderSizeObserver(callback: callback);
   
     void syncRenderObject(SizeObserver old) {
       super.syncRenderObject(old);
  
positive.code:     root.callback = null;
      super.remove();
    }
  
  }
  
  class ClipRect extends OneChildRenderObjectWrapper {
    ClipRect({ String key, Widget child })
      : super(key: key, child: child);
  
    RenderClipRect get root => super.root;
    RenderClipRect createNode() => new RenderClipRect();
  
    // Nothing to sync, so we don't implement syncRenderObject()
  }
  
  class ClipRRect extends OneChildRenderObjectWrapper {
    final double xRadius;
    final double yRadius;
    ClipRRect({ String key, Widget child, this.xRadius, this.yRadius })
      : super(key: key, child: child);
  
    RenderClipRRect get root => super.root;
    RenderClipRRect createNode() => new RenderClipRRect(xRadius: xRadius, yRadius: yRadius);
  
    void syncRenderObject(ClipRRect old) {
      super.syncRenderObject(old);
  
negative.code: 
  class Image extends LeafRenderObjectWrapper {
    Image({ sky.Image image, this.size })
      : image = image,
        super(key: image.hashCode.toString()); // TODO(ianh): Find a way to uniquely identify the sky.Image rather than using hashCode, which could collide
  
    final sky.Image image;
    final Size size;
  
    RenderImage createNode() => new RenderImage(image, size);
    RenderImage get root => super.root;
  
    void syncRenderObject(Widget old) {
      super.syncRenderObject(old);
      root.image = image;
  