anchor.diff:  /// is inflated. For compositions that can change dynamically, e.g. due to
   /// having an internal clock-driven state, or depending on some system state,
   /// consider using [StatefulWidget].
  +///
  +/// ## Sample code
  +///
  +/// The following is a skeleton of a stateless widget subclass called `GreenFrog`:
  +///
  +/// ```dart
  +/// class GreenFrog extends StatelessWidget {
  +///   const GreenFrog({ Key key }) : super(key: key);
  +///
  +///   @override
  +///   Widget build(BuildContext context) {
  +///     return new Container(color: const Color(0xFF2DBD3A));
  +///   }
  +/// }
  +/// ```
  +///
  +/// Normally widgets have more constructor arguments, each of which corresponds
  +/// to a `final` property. The next example shows the more generic widget `Frog`
  +/// which can be given a color and a child:
  +///
  +/// ```dart
  +/// class Frog extends StatelessWidget {
  +///   const Frog({
  +///     Key key,
  +///     this.color: const Color(0xFF2DBD3A),
  +///     this.child,
  +///   }) : super(key: key);
  +///
  +///   final Color color;
  +///
  +///   final Widget child;
  +///
  +///   @override
  +///   Widget build(BuildContext context) {
  +///     return new Container(color: color, child: child);
  +///   }
  +/// }
  +/// ```
  +///
  +/// By convention, widget constructors only use named arguments. Named arguments
  +/// can be marked as required using [@required]. Also by convention, the first
  +/// argument is [key], and the last argument is `child`, `children`, or the
  +/// equivalent.
   ///
   /// See also:
   ///
  
positive.code: /// A [ParentDataWidget] is specific to a particular kind of [RenderObject], and
  /// thus also to a particular [RenderObjectWidget] class. That class is `T`, the
  /// [ParentDataWidget] type argument.
  abstract class ParentDataWidget<T extends RenderObjectWidget> extends ProxyWidget {
    /// Abstract const constructor. This constructor enables subclasses to provide
    /// const constructors so that they can be used in const expressions.
  
negative.code: ///
  /// Inherited widgets, when referenced in this way, will cause the consumer to
  /// rebuild when the inherited widget itself changes state.
  ///
  /// ## Sample code
  ///
  /// The following is a skeleton of an inherited widget called `FrogColor`:
  ///
  /// ```dart
  /// class FrogColor extends InheritedWidget {
  ///   const FrogColor(
  ///     Key key,
  ///     @required this.color,
  ///     @required Widget child,
  ///   }) : assert(color != null),
  ///        assert(child != null),
  ///        super(key: key, child: child);
  ///
  ///   final Color color;
  ///
  ///   static FrogColor of(BuildContext context) {
  ///     return context.inheritFromWidgetOfExactType(FrogColor);
  ///   }
  ///
  ///   @override
  ///   bool updateShouldNotify(FrogColor old) => color != old.color;
  /// }
  /// ```
  ///
  /// The convention is to provide a static method `of` on the [InheritedWidget]
  /// which does the call to [BuildContext.inheritFromWidgetOfExactType]. This
  /// allows the class to define its own fallback logic in the case of there not
  /// being a widget in scope. In the example above, the value returned will be
  /// null in that case, but it could also have defaulted to a value.
  ///
  /// Sometimes, the `of` method returns the data rather than the inherited
  /// widget; for example, in this case it could have returned a [Color] instead
  /// of the [FrogColor] widget.
  ///
  /// Occasionally, the inherited widget is an implementation detail of another
  /// class, and is therefore private. The `of` method in that case is typically
  /// put on the public class instead. For example, [Theme] is implemented as a
  /// [StatelessWidget] that builds a private inherited widget; [Theme.of] looks
  /// for that inherited widget using [BuildContext.inheritFromWidgetOfExactType]
  /// and then returns the [ThemeData].
  ///
  /// See also:
  ///
  ///  * [StatefulWidget] and [State], for widgets that can build differently
  ///    several times over their lifetime.
  ///  * [StatelessWidget], for widgets that always build the same way given a
  ///    particular configuration and ambient state.
  ///  * [Widget], for an overview of widgets in general.
  abstract class InheritedWidget extends ProxyWidget {
    /// Abstract const constructor. This constructor enables subclasses to provide
    /// const constructors so that they can be used in const expressions.
  