anchor.diff:    /// arguments in the list. It must be provided if [leadingCollections] or
     /// [trailingCollections] is non-zero.
     NamedRule(
  -      Rule? collectionRule, int leadingCollections, int trailingCollections)
  -      : super._(leadingCollections, trailingCollections) {
  +      Rule? collectionRule, int leadingCollections, int trailingCollections) {
       if (leadingCollections > 0 || trailingCollections > 0) {
         // Split only before the first argument. Don't allow the collections to
         // split.
  
positive.code:   /// This and [_leadingCollections] cannot both be positive.
    final int _trailingCollections;
  
    /// If true, then inner rules that are written will force this rule to split.
    ///
    /// Temporarily disabled while writing collection arguments so that they can
    /// be multi-line without forcing the whole argument list to split.
    bool _trackInnerRules = true;
  
    /// Don't split when an inner collection rule splits.
    @override
    bool get splitsOnInnerRules => _trackInnerRules;
  
    ArgumentRule._(this._leadingCollections, this._trailingCollections);
  
    /// Remembers [chunk] as containing the split that occurs right before an
    /// argument in the list.
    void beforeArgument(Chunk? chunk) {
      _arguments.add(chunk);
    }
  
    /// Disables tracking inner rules while a collection argument is written.
    void disableSplitOnInnerRules() {
      assert(_trackInnerRules == true);
      _trackInnerRules = false;
    }
  
    /// Re-enables tracking inner rules.
    void enableSplitOnInnerRules() {
      assert(_trackInnerRules == false);
      _trackInnerRules = true;
    }
  }
  
  /// Rule for handling positional argument lists.
  ///
  /// The number of values is based on the number of arguments and whether or not
  /// there are bodies. The first two values are always:
  ///
  /// * 0: Do not split at all.
  /// * 1: Split only before the first argument.
  ///
  /// Then there is a value for each argument, to split before that argument.
  /// These values work back to front. So, for a two-argument list, value 2 splits
  /// after the second argument and value 3 splits after the first.
  ///
  /// Then there is a value that splits before every argument.
  ///
  /// Finally, if there are collection arguments, there is another value that
  /// splits before all of the non-collection arguments, but does not split
  /// before the collections, so that they can split internally.
  class PositionalRule extends ArgumentRule {
    /// Creates a new rule for a positional argument list.
    ///
    /// [argumentCount] is the number of arguments that will be added to the rule
  
negative.code:   /// The chunks prior to each positional argument.
    final List<Chunk?> _arguments = [];
  
    /// If true, then inner rules that are written will force this rule to split.
    ///
    /// Temporarily disabled while writing collection arguments so that they can
    /// be multi-line without forcing the whole argument list to split.
    bool _trackInnerRules = true;
  
    /// Don't split when an inner collection rule splits.
    @override
    bool get splitsOnInnerRules => _trackInnerRules;
  
    /// Remembers [chunk] as containing the split that occurs right before an
    /// argument in the list.
    void beforeArgument(Chunk? chunk) {
      _arguments.add(chunk);
    }
  
    /// Disables tracking inner rules while a collection argument is written.
    void disableSplitOnInnerRules() {
      assert(_trackInnerRules == true);
      _trackInnerRules = false;
    }
  
    /// Re-enables tracking inner rules.
    void enableSplitOnInnerRules() {
      assert(_trackInnerRules == false);
      _trackInnerRules = true;
    }
  }
  
  /// Rule for handling positional argument lists.
  ///
  /// The number of values is based on the number of arguments and whether or not
  /// there are bodies. The first two values are always:
  ///
  /// * 0: Do not split at all.
  /// * 1: Split only before the first argument.
  ///
  /// Then there is a value for each argument, to split before that argument.
  /// These values work back to front. So, for a two-argument list, value 2 splits
  /// after the second argument and value 3 splits after the first.
  ///
  /// Then there is a value that splits before every argument.
  ///
  /// Finally, if there are collection arguments, there is another value that
  /// splits before all of the non-collection arguments, but does not split
  /// before the collections, so that they can split internally.
  class PositionalRule extends ArgumentRule {
    /// The number of leading collection arguments.
    ///
    /// This and [_trailingCollections] cannot both be positive. If every
  