anchor.diff:    }
   
     /// Called when this object is removed from the tree.
  -  /// The object might momentarily be reattached to the tree elsewhere.
  -  ///
  -  /// Use this to clean up any links between this state and other
  -  /// elements in the tree (e.g. if you have provided an ancestor with
  -  /// a pointer to a descendant's renderObject).
  +  ///
  +  /// The framework calls this method whenever it removes this [State] object
  +  /// from the tree. In some cases, the framework will reinsert the [State]
  +  /// object into another part of the tree (e.g., if the subtree containing this
  +  /// [State] object is grafted from one location in the tree to another). 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.
  +  ///
  +  /// 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]).
  +  ///
  +  /// If you override this, make sure to end your method with a call to
  +  /// super.deactivate().
     @mustCallSuper
     void deactivate() { }
   
     /// Called when this object is removed from the tree permanently.
  -  /// Override this to clean up any resources allocated by this
  -  /// object.
  +  ///
  +  /// The framework calls this method when this [State] object will never
  +  /// build again. 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.
  +  ///
  +  /// Subclasses should override this method to release any resources retained
  +  /// by this object (e.g., stop any active animations).
     ///
     /// If you override this, make sure to end your method with a call to
     /// super.dispose().
  
positive.code:   /// _MyState createState() => new _MyState();
    /// ```
    ///
    /// The framework can call this function 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
  
negative.code:     assert(() { _debugLifecycleState = _StateLifecycle.defunct; return true; });
    }
  
    /// Describes the part of the user interface represented by this widget.
    ///
    /// The framework calls this method in a number of different situations:
    ///
    ///  * After calling [initState].
    ///  * After calling [didUpdateConfig].
    ///  * After receiving a call to [setState].
    ///  * After a dependency of this [State] object changes (e.g., an
    ///    [InheritedWidget] referenced by the previous [build] changes).
    ///  * After calling [deactivate] and then reinserting the [State] object into
    ///    the tree at another location.
    ///
    /// The framework replaces the subtree below this widget with the widget
    /// returned by this method, either by updating the existing subtree or by
    /// removing the subtree and inflating a new subtree, depending on whether the
    /// widget returned by this method can update the root of the existing
    /// subtree, as determined by calling [Widget.canUpdate].
    ///
    /// Typically implementations return a newly created constellation of widgets
    /// that are configured with information from this widget's constructor, the
    /// given [BuildContext], and the internal state of this [State] object.
    ///
    /// The given [BuildContext] 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
    /// [BuildContext] argument is always the same as the [context] property of
    /// this [State] object and will remain the same for the lifetime of this
    /// object. The [BuildContext] argument is provided redundantly here so that
    /// this method matches the signature for a [WidgetBuilder].
    @protected
    Widget build(BuildContext context);
  
    /// Trampoline to make the [build] closure library-accessible.
    WidgetBuilder get _build => build;
  
    /// Called when a dependencies of this [State] object changes.
    ///
    /// For example, if the previous call to [build] referenced an
    /// [InheritedWidget] that later changed, the framework would call this
    /// method to notify this object about the change.
    ///
    /// Subclasses rarely override this method because the framework always
    /// calls [build] after a dependency changes. Some subclasses do override
    /// this method because they need to do some expensive work (e.g., network
    /// fetches) when their dependencies change, and that work would be too
    /// expensive to do for every build.
    @mustCallSuper
    void dependenciesChanged() { }
  
  