anchor.diff:    /// 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
  
positive.code:       {required int argumentCount,
        int leadingCollections = 0,
        int trailingCollections = 0})
        : super._(leadingCollections, trailingCollections) {
      if (collectionRule != null) {
        // 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);
        }
      }
    }
  
  
negative.code:   /// arguments in the list. It must be provided if [leadingCollections] or
    /// [trailingCollections] is non-zero.
    NamedRule(
        Rule? collectionRule, int leadingCollections, int trailingCollections) {
      if (leadingCollections > 0 || trailingCollections > 0) {
        // Split only before the first argument. Don't allow the collections to
        // split.
  