anchor.diff:    /// called.
     ready,
   
  -  /// The [State.dispose] function has been called and the [State] object is
  +  /// The [State.dispose] method has been called and the [State] object is
     /// no longer able to build.
     defunct,
   }
  
positive.code:     assert(() { _debugLifecycleState = _StateLifecycle.initialized; return true; });
    }
  
    /// Called whenever the configuration changes. Override this method to update
    /// additional state when the config field's value is changed.
    void didUpdateConfig(T oldConfig) { }
  
    /// Whenever you need to change internal state for a State object, make the
    /// change in a function that you pass to setState(), as in:
    ///
    /// ```dart
    /// setState(() { myState = newValue });
    /// ```
    ///
    /// If you just change the state directly without calling setState(), then the
    /// widget will not be scheduled for rebuilding, meaning that its rendering
    /// will not be updated.
    @protected
    void setState(VoidCallback fn) {
      assert(() {
  
negative.code:   }
  
    /// Called when this object is removed from the tree.
    ///
    /// 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.
    ///
    /// 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().
  