anchor.diff:    /// 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
  
positive.code:   /// The chunks prior to each positional argument.
    final List<Chunk?> _arguments = [];
  
    /// The number of leading collection arguments.
    ///
    /// This and [_trailingCollections] cannot both be positive. If every
  
negative.code:       {required int argumentCount,
        int leadingCollections = 0,
        int trailingCollections = 0})
        : _leadingCollections = leadingCollections,
          _trailingCollections = trailingCollections {
      // Don't split inside collections if there are leading collections and
      // we split before the first argument.
      if (leadingCollections > 0) {
        addConstraint(1, collectionRule!, Rule.unsplit);
      }
  
      // If we're only splitting before the non-collection arguments, the
      // intent is to split inside the collections, so force that here.
      if (leadingCollections > 0 || trailingCollections > 0) {
        addConstraint(argumentCount + 1, collectionRule!, 1);
      }
  
      // Split before a single argument. If it's in the middle of the collection
      // arguments, don't allow them to split.
      for (var argument = 0; argument < leadingCollections; argument++) {
        var value = argumentCount - argument + 1;
        addConstraint(value, collectionRule!, Rule.unsplit);
      }
  
      for (var argument = argumentCount - trailingCollections;
          argument < argumentCount;
          argument++) {
        var value = argumentCount - argument + 1;
        addConstraint(value, collectionRule!, Rule.unsplit);
      }
    }
  
  