anchor.diff:    ///
     /// {@tool sample}
     ///
  -  /// Sample code implementing an implicitly animated widget's `State`.
  +  /// This sample implements an implicitly animated widget's `State`.
     /// The widget animates between colors whenever `widget.targetColor`
     /// changes.
     ///
  
positive.code:     return shouldStartAnimation;
    }
  
    /// Subclasses must implement this function by running through the following
    /// steps for each animatable facet in the class:
    ///
    /// 1. Call the visitor callback with three arguments, the first argument
    /// being the current value of the Tween<T> object that represents the
    /// tween (initially null), the second argument, of type T, being the value
    /// on the Widget that represents the current target value of the
    /// tween, and the third being a callback that takes a value T (which will
    /// be the second argument to the visitor callback), and that returns an
    /// Tween<T> object for the tween, configured with the given value
    /// as the begin value.
    ///
    /// 2. Take the value returned from the callback, and store it. This is the
    /// value to use as the current value the next time that the [forEachTween]
    /// method is called.
    ///
    /// Subclasses that contain properties based on tweens created by
    /// [forEachTween] should override [didUpdateTweens] to update those
  
negative.code: ///
  /// This is the type of one of the arguments of [TweenVisitor], the signature
  /// used by [AnimatedWidgetBaseState.forEachTween].
  ///
  /// Instances of this function are expected to take a value and return a tween
  /// beginning at that value.
  typedef TweenConstructor<T> = Tween<T> Function(T targetValue);
  
  /// Signature for callbacks passed to [ImplicitlyAnimatedWidgetState.forEachTween].
  ///
  /// {@template flutter.widgets.implicit_animations.tweenVisitorArguments}
  /// The `tween` argument should contain the current tween value. This will
  /// initially be null when the state is first initialized.
  ///
  /// The `targetValue` argument should contain the value toward which the state
  /// is animating. For instance, if the state is animating its widget's
  /// opacity value, then this argument should contain the widget's current
  /// opacity value.
  ///
  /// The `constructor` argument should contain a function that takes a value
  /// (the widget's value being animated) and returns a tween beginning at that
  /// value.
  ///
  /// {@endtemplate}
  ///
  /// `forEachTween()` is expected to update its tween value to the return value
  /// of this visitor.
  ///
  /// The `<T>` parameter specifies the type of value that's being animated.
  typedef TweenVisitor<T> = Tween<T> Function(Tween<T> tween, T targetValue, TweenConstructor<T> constructor);
  
  /// A base class for the `State` of widgets with implicit animations.
  ///
  /// [ImplicitlyAnimatedWidgetState] requires that subclasses respond to the
  /// animation themselves. If you would like `setState()` to be called
  /// automatically as the animation changes, use [AnimatedWidgetBaseState].
  ///
  /// Properties that subclasses choose to animate are represented by [Tween]
  /// instances. Subclasses must implement the [forEachTween] method to allow
  /// [ImplicitlyAnimatedWidgetState] to iterate through the widget's fields and
  /// animate them.
  abstract class ImplicitlyAnimatedWidgetState<T extends ImplicitlyAnimatedWidget> extends State<T> with SingleTickerProviderStateMixin<T> {
    /// The animation controller driving this widget's implicit animations.
    @protected
  