anchor.diff:  }
   
   class FutureImage extends StatefulComponent {
  -  FutureImage({ this.image, this.size });
  +  FutureImage({ String key, this.image, this.size }) : super(key: key);
   
     Future<sky.Image> image;
     Size size;
  +
     sky.Image _resolvedImage;
  -
  -  void didMount() {
  -    super.didMount();
  -    _resolveImage();
  -  }
   
     void _resolveImage() {
       image.then((sky.Image resolvedImage) {
  
positive.code:     });
    }
  
    void syncFields(FutureImage source) {
      bool needToResolveImage = (image != source.image);
      image = source.image;
  
negative.code:     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;
  
    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);
  
    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, 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;
  
    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);
  
    final double offset;
  
    RenderViewport createNode() => new RenderViewport(scrollOffset: new Offset(0.0, offset));
    RenderViewport get root => super.root;
  
    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;
  
    void syncRenderObject(SizeObserver old) {
      super.syncRenderObject(old);
  