anchor.diff:    /// created for that particular [Widget].
     bool _debugTypesAreRight(Widget widget) => widget is T;
   
  -  /// 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 location in the tree where this widget builds.
     ///
     /// The framework associates [State] objects with a [BuildContext] after
  
positive.code: 
  /// 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
  
negative.code:   /// given widget might be with multiple different [BuildContext] arguments
    /// over time if the widget is moved around the tree or if the widget is
    /// inserted into the tree in multiple places at once.
    ///
    /// The implementation of this method must only depend on:
    ///
    /// * the fields of the widget, which themselves must not change over time,
    ///   and
    /// * any ambient state obtained from the `context` using
    ///   [BuildContext.inheritFromWidgetOfExactType].
    ///
    /// If a widget's [build] method is to depend on anything else, use a
    /// [StatefulWidget] instead.
    @protected
    Widget build(BuildContext context);
  }
  
  /// A widget that has mutable state.
  ///
  /// State is information that (1) can be read synchronously when the widget is
  /// built and (2) might change during the lifetime of the widget. It is the
  /// responsibility of the widget implementer to ensure that the [State] is
  /// promptly notified when such state changes, using [State.setState].
  ///
  /// A stateful widget is a widget that describes part of the user interface by
  /// building a constellation of other widgets that describe the user interface
  /// more concretely. The building process continues recursively until the
  /// description of the user interface is fully concrete (e.g., consists
  /// entirely of [RenderObjectWidget]s, which describe concrete [RenderObject]s).
  ///
  /// Stateless widget are useful when the part of the user interface you are
  /// describing can change dynamically, e.g. due to having an internal
  