anchor.diff:  typedef void StateSetter(VoidCallback fn);
   
   /// The logic and internal state for a [StatefulWidget].
  +///
  +/// State is information (1) that can be read synchronously when the widget is
  +/// built and (2) for which we will be notified when it changes.
  +///
  +/// [State] objects are created by the framework by calling the
  +/// [StatefulWidget.createState] method when inflating a [StatefulWidget] to
  +/// insert it into the tree. Because a given [StatefulWidget] instance can be
  +/// inflated multiple times (e.g., the widget is incorporated into the tree in
  +/// multiple places at once), there might be more than one [State] object
  +/// associated with a given [StatefulWidget] instance. Similarly, if a
  +/// [StatefulWidget] is removed from the tree and later inserted in to the tree
  +/// again, the framework will call [StatefulWidget.createState] again to create
  +/// a fresh [State] object, simplifying the lifecycle of [State] objects.
  +///
  +/// [State] objects have the following lifecycle:
  +///
  +///  * The framework creates a [State] object by calling
  +///    [StatefulWidget.createState].
  +///  * The newly created [State] object is associated with a [BuildContext].
  +///    This association is permanent: the [State] object will never change its
  +///    [BuildContext]. However, the [BuildContext] itself can be moved around
  +///    the tree along with its subtree. At this point, the [State] object is
  +///    considered [mounted].
  +///  * The framework calls [initState]. Subclasses of [State] should override
  +///    [initState] to perform one-time initialization that depends on the
  +///    [BuildContext] or the widget, which are available as the [context] and
  +///    [config] properties, respectively, when the [initState] method is
  +///    called.
  +///  * At this point, the [State] object is fully initialized and the framework
  +///    might call its [build] method any number of times to obtain a
  +///    description of the user interface for this subtree. [State] objects can
  +///    spontanteously request to rebuild their subtree by callings their
  +///    [setState] method, which indicates that some of their internal state
  +///    has changed in a way that might impact the user interface in this
  +///    subtree.
  +///  * During this time, a parent widget might rebuild and request that this
  +///    location in the tree update to display a new widget with the same
  +///    [runtimeType] and [key]. When this happens, the framework will update the
  +///    [config] property to refer to the new widget and then call the
  +///    [didUpdateConfig] method with the previous widget as an argument.
  +///    [State] objects should override [didUpdateConfig] to respond to changes
  +///    in their associated wiget (e.g., to start implicit animations).
  +///    The framework always calls [build] after calling [didUpdateConfig], which
  +///    means any calls to [setState] in [didUpdateConfig] are redundant.
  +///  * If the subtree containing the [State] object is removed from the tree
  +///    (e.g., because the parent built a widget with a different [runtimeType]
  +///    or [key]), the framework calls the [deactivate] method. Subclasses
  +///    should override this method to clean up any links between this object
  +///    and other elements in the tree (e.g. if you have provided an ancestor
  +///    with a pointer to a descendant's [RenderObject]).
  +///  * At this point, the framework might reinsert this subtree into another
  +///    part of the tree. If that happens, the framework will ensure that it
  +///    calls [build] to give the [State] object a chance to adapt to its new
  +///    location in the tree. If the framework does reinsert this subtree, it
  +///    will do so before the end of the animation frame in which the subtree was
  +///    removed from the tree. For this reason, [State] objects can defer
  +///    releasing most resources until the framework calls their [dispose]
  +///    method.
  +///  * If the framework does not reinsert this subtree by the end of the current
  +///    animation frame, the framework will call [dispose], which indiciates that
  +///    this [State] object will never build again. Subclasses should override
  +///    this method to release any resources retained by this object (e.g.,
  +///    stop any active animations).
  +///  * After the framework calls [dispose], the [State] object is considered
  +///    unmounted and the [mounted] property is false. It is an error to call
  +///    [setState] at this point. This stage of the lifecycle is terminal: there
  +///    is no way to remount a [State] object that has been disposed.
  +///
  +/// See also:
  +///
  +///  * [StatefulWidget]
  +///  * [StatelessWidget]
   @optionalTypeArgs
   abstract class State<T extends StatefulWidget> {
  -  /// The current configuration (an instance of the corresponding
  -  /// [StatefulWidget] class).
  +  /// The current configuration.
  +  ///
  +  /// A [State] object's configuration is the corresponding [StatefulWidget]
  +  /// instance. This property is initialized by the framework before calling
  +  /// [initState]. If the parent updates this location in the tree to a new
  +  /// widget with the same [runtimeType] and [key] as the current configuration,
  +  /// the framework will update this property to refer to the new widget and
  +  /// then call [didUpdateConfig], passing the old configuration as an argument.
     T get config => _config;
     T _config;
   
  -  /// This is used to verify that State objects move through life in an orderly fashion.
  +  /// The current stage in the lifecycle for this state object.
  +  ///
  +  /// This field is used by the framework when asserts are enabled to verify
  +  /// that [State] objects move through their lifecycle in an orderly fashion.
     _StateLifecycle _debugLifecycleState = _StateLifecycle.created;
   
  -  /// Verifies that the State that was created is one that expects to be created
  -  /// for that particular Widget.
  +  /// Verifies that the [State] that was created is one that expects to be
  +  /// created for that particular [Widget].
     bool _debugTypesAreRight(Widget widget) => widget is T;
   
  -  /// Pointer to the owner Element object
  +  /// The [StatefulElement] that owns this [State] object.
  +  ///
  +  /// The framework associates [State] objects with an element after creating
  +  /// them with [StatefulWidget.createState] and before calling [initState]. The
  +  /// association is permanent: the [State] object will never change its
  +  /// element. However, the element itself can be moved around the tree.
  +  ///
  +  /// After calling [dispose], the framework severs the [State] object's
  +  /// connection with the element.
     StatefulElement _element;
   
  -  /// The context in which this object will be built
  +  /// The location in the tree where this widget builds.
  +  ///
  +  /// The framework associates [State] objects with a [BuildContext] after
  +  /// creating them with [StatefulWidget.createState] and before calling
  +  /// [initState]. The association is permanent: the [State] object will never
  +  /// change its [BuildContext]. However, the [BuildContext] itself can be moved
  +  /// around the tree.
  +  ///
  +  /// After calling [dispose], the framework severs the [State] object's
  +  /// connection with the [BuildContext].
     BuildContext get context => _element;
   
  +  /// Whether this [State] object is currently in a tree.
  +  ///
  +  /// After creating a [State] object and before calling [initState], the
  +  /// framework "mounts" the [State] object by associating it with a
  +  /// [BuildContext]. The [State] object remains mounted until the framework
  +  /// calls [dispose], after which time the framework will never ask the [State]
  +  /// object to [build] again.
  +  ///
  +  /// It is an error to call [setState] unless [mounted] is true.
     bool get mounted => _element != null;
   
  -  /// Called when this object is inserted into the tree. Override this function
  -  /// to perform initialization that depends on the location at which this
  -  /// object was inserted into the tree or on the widget configuration object.
  +  /// Called when this object is inserted into the tree.
  +  ///
  +  /// Override this method to perform initialization that depends on the
  +  /// location at which this object was inserted into the tree (i.e., [context])
  +  /// or on the widget used to configure this object (i.e., [config])
  +  ///
  +  /// The framework will call this method exactly once for each [State] object
  +  /// it creates.
     ///
     /// If you override this, make sure your method starts with a call to
     /// super.initState().
  
positive.code:     assert(() { _debugLifecycleState = _StateLifecycle.defunct; return true; });
    }
  
    /// Returns another Widget out of which this [StatefulWidget] is built.
    /// Typically that Widget will have been configured with further children,
    /// such that really this function returns a tree of configuration.
    ///
    /// The given build context object contains information about the location in
    /// the tree at which this widget is being built. For example, the context
    /// provides the set of inherited widgets for this location in the tree.
    ///
    /// The context argument is always the same as [State.context]. This argument
    /// is provided redundantly here to match the [WidgetBuilder] function
    /// signature used by [StatelessWidget.build] and other widgets.
    @protected
    Widget build(BuildContext context);
  
    /// Trampoline to make the [build] closure library-accessible.
    WidgetBuilder get _build => build;
  
    /// Called when an Inherited widget in the ancestor chain has changed. Usually
    /// there is nothing to do here; whenever this is called, build() is also
    /// called.
    @mustCallSuper
    void dependenciesChanged() { }
  
  
negative.code:   /// _MyState createState() => new _MyState();
    /// ```
    ///
    /// The framework can call this method multiple times over the lifetime of
    /// a [StatefulWidget]. For example, if the widget is inserted into the tree
    /// in multiple locations, the framework will create a separate [State] object
    /// for each location. Similarly, if the widget is removed from the tree and
  