anchor.diff:  /// * the declaration is referenced outside of its the defining library or a
   ///   library which is in the `test` folder of the defining package.
   const _VisibleForTesting visibleForTesting = const _VisibleForTesting();
  +
  +/// Used to annotate a class.
  +///
  +/// See [immutable] for more details.
  +class Immutable {
  +  /// A human-readable explanation of the reason why the class is immutable.
  +  final String reason;
  +
  +  /// Initialize a newly created instance to have the given [reason].
  +  const Immutable([this.reason]);
  +}
   
   /// Used to annotate a named parameter `p` in a method or function `f`.
   ///
  
positive.code:   /// Initialize a newly created instance to have the given [reason].
    const Required([this.reason]);
  }
  
  /// Used to annotate a parameter of an instance method that overrides another
  /// method.
  ///
  /// Indicates that this parameter may have a tighter type than the parameter on
  /// its superclass. The actual argument will be checked at runtime to ensure it
  /// is a subtype of the overridden parameter type.
  const _Checked checked = const _Checked();
  
  /// Used to annotate a field is allowed to be overridden in Strong Mode.
  const _Virtual virtual = const _Virtual();
  
  class _Checked {
    const _Checked();
  
negative.code: /// * the annotation is associated with a method that has this annotation that
  ///   can return anything other than a newly allocated object or `null`.
  const _Factory factory = const _Factory();
  
  /// Used to annotate a class `C`. Indicates that `C` and all subtypes of `C`
  /// must be immutable.
  ///
  /// A class is immutable if all of the instance fields of the class, whether
  /// defined directly or inherited, are `final`.
  ///
  /// Tools, such as the analyzer, can provide feedback if
  /// * the annotation is associated with anything other than a class, or
  /// * a class that has this annotation or extends, implements or mixes in a
  ///   class that has this annotation is not immutable.
  const Immutable immutable = const Immutable();
  
  /// Used to annotate a const constructor `c`. Indicates that any invocation of
  /// the constructor must use the keyword `const` unless one or more of the
  