anchor.diff:  /// set of states.
   typedef MaterialPropertyResolver<T> = T Function(Set<MaterialState> states);
   
  -/// Defines a [Color] whose value depends on a set of [MaterialState]s which
  -/// represent the interactive state of a component.
  -///
  -/// This is useful for improving the accessibility of text in different states
  -/// of a component. For example, in a [FlatButton] with blue text, the text will
  -/// become more difficult to read when the button is hovered, focused, or pressed,
  -/// because the contrast ratio between the button and the text will decrease. To
  -/// solve this, you can use [MaterialStateColor] to make the text darker when the
  -/// [FlatButton] is hovered, focused, or pressed.
  +/// Defines a [Color] that is also a [MaterialStateProperty].
  +///
  +/// This class exists to enable widgets with [Color] valued properties
  +/// to also accept [MaterialStateProperty<Color>] values. A material
  +/// state color property represents a color which depends on
  +/// a widget's "interactive state". This state is represented as a
  +/// [Set] of [MaterialState]s, like [MaterialState.pressed],
  +/// [MaterialState.focused] and [MaterialState.hovered].
   ///
   /// To use a [MaterialStateColor], you can either:
   ///   1. Create a subclass of [MaterialStateColor] and implement the abstract `resolve` method.
   ///   2. Use [MaterialStateColor.resolveWith] and pass in a callback that
   ///      will be used to resolve the color in the given states.
   ///
  -/// This should only be used as parameters when they are documented to take
  -/// [MaterialStateColor], otherwise only the default state will be used.
  +/// If a [MaterialStateColor] is used for a property or a parameter that doesn't
  +/// support resolving [MaterialStateProperty<Color>]s, then its default color
  +/// value will be used for all states.
  +///
  +/// To define a `const` [MaterialStateColor], you'll need to extend
  +/// [MaterialStateColor] and override its [resolve] method. You'll also need
  +/// to provide a `defaultValue` to the super constructor, so that we can know
  +/// at compile-time what its default color is.
   ///
   /// {@tool snippet}
   ///
  -/// This example shows how you could pass a `MaterialStateColor` to `FlatButton.textColor`.
  -/// Here, the text color will be `Colors.blue[900]` when the button is being
  -/// pressed, hovered, or focused. Otherwise, the text color will be `Colors.blue[600]`.
  +/// This example defines a `MaterialStateColor` with a const constructor.
   ///
   /// ```dart
  -/// Color getTextColor(Set<MaterialState> states) {
  -///   const Set<MaterialState> interactiveStates = <MaterialState>{
  -///     MaterialState.pressed,
  -///     MaterialState.hovered,
  -///     MaterialState.focused,
  -///   };
  -///   if (states.any(interactiveStates.contains)) {
  -///     return Colors.blue[900];
  +/// class MyColor extends MaterialStateColor {
  +///   static const int _defaultColor = 0xcafefeed;
  +///   static const int _pressedColor = 0xdeadbeef;
  +///
  +///   const MyColor() : super(_defaultColor);
  +///
  +///   @override
  +///   Color resolve(Set<MaterialState> states) {
  +///     if (states.contains(MaterialState.pressed)) {
  +///       return const Color(_pressedColor);
  +///     }
  +///     return const Color(_defaultColor);
   ///   }
  -///   return Colors.blue[600];
   /// }
  -///
  -/// FlatButton(
  -///   child: Text('FlatButton'),
  -///   onPressed: () {},
  -///   textColor: MaterialStateColor.resolveWith(getTextColor),
  -/// ),
   /// ```
   /// {@end-tool}
   abstract class MaterialStateColor extends Color implements MaterialStateProperty<Color> {
     /// Creates a [MaterialStateColor].
  -  ///
  -  /// If you want a `const` [MaterialStateColor], you'll need to extend
  -  /// [MaterialStateColor] and override the [resolve] method. You'll also need
  -  /// to provide a `defaultValue` to the super constructor, so that we can know
  -  /// at compile-time what the value of the default [Color] is.
  -  ///
  -  /// {@tool snippet}
  -  ///
  -  /// In this next example, we see how you can create a `MaterialStateColor` by
  -  /// extending the abstract class and overriding the `resolve` method.
  -  ///
  -  /// ```dart
  -  /// class TextColor extends MaterialStateColor {
  -  ///   static const int _defaultColor = 0xcafefeed;
  -  ///   static const int _pressedColor = 0xdeadbeef;
  -  ///
  -  ///   const TextColor() : super(_defaultColor);
  -  ///
  -  ///   @override
  -  ///   Color resolve(Set<MaterialState> states) {
  -  ///     if (states.contains(MaterialState.pressed)) {
  -  ///       return const Color(_pressedColor);
  -  ///     }
  -  ///     return const Color(_defaultColor);
  -  ///   }
  -  /// }
  -  /// ```
  -  /// {@end-tool}
     const MaterialStateColor(int defaultValue) : super(defaultValue);
   
     /// Creates a [MaterialStateColor] from a [MaterialPropertyResolver<Color>]
  
positive.code: ///
  /// See also:
  ///
  ///  * [MaterialStateColor], a color that has a `resolve` method that can
  ///    return a different color depending on the state of the widget that it
  ///    is used in.
  enum MaterialState {
    /// The state when the user drags their mouse cursor over the given widget.
    ///
  
negative.code: ///     }
  ///     return SystemMouseCursors.click;
  ///   }
  ///   @override
  ///   String get debugDescription => 'ListTileCursor()';
  /// }
  /// ```
  ///
  /// ```dart
  /// Widget build(BuildContext context) {
  ///   return ListTile(
  ///     title: Text('Disabled ListTile'),
  ///     enabled: false,
  ///     mouseCursor: ListTileCursor(),
  ///   );
  /// }
  /// ```
  /// {@end-tool}
  ///
  /// This class should only be used for parameters which are documented to take
  /// [MaterialStateMouseCursor], otherwise only the default state will be used.
  ///
  /// See also:
  ///
  