Harden named arguments if a hard split occurs in the positional ones.

lib/src/chunk_builder.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart_style.src.chunk_builder;
 
 import 'chunk.dart';
 import 'dart_formatter.dart';
 import 'debug.dart' as debug;
 import 'line_splitter.dart';
@@ skipping 29 matching lines @@
   /// most recent split, even if the visitor "creates" the split before changing
   /// indentation or nesting.
   Whitespace _pendingWhitespace = Whitespace.none;
 
   /// The nested stack of rules that are currently in use.
   ///
   /// New chunks are implicitly split by the innermost rule when the chunk is
   /// ended.
   final _rules = <Rule>[];
 
+  /// The set of rules known to contain hard splits that will in turn force
+  /// these rules to harden.
+  ///
+  /// This is accumulated lazily while chunks are being built. Then, once they
+  /// are all done, the rules are all hardened. We do this later because some
+  /// rules may not have all of their constraints fully wired up until after
+  /// the hard split appears. For example, a hard split in a positional
+  /// argument list needs to force the named arguments to split too, but we
+  /// don't create that rule until after the positional arguments are done.
+  final _rulesToHarden = new Set<Rule>();
+
   /// The list of rules that are waiting until the next whitespace has been
   /// written before they start.
   final _lazyRules = <Rule>[];
 
   /// The indexes of the chunks owned by each rule (except for hard splits).
   final _ruleChunks = <Rule, List<int>>{};
 
   /// The nested stack of spans that are currently being written.
   final _openSpans = <OpenSpan>[];
 
@@ skipping 666 matching lines @@
 
     return true;
   }
 
   /// Pre-processes the chunks after they are done being written by the visitor
   /// but before they are run through the line splitter.
   ///
   /// Marks ranges of chunks that can be line split independently to keep the
   /// batches we send to [LineSplitter] small.
   void _divideChunks() {
+    // Harden all of the rules that we know get forced by containing hard
+    // splits, along with all of the other rules they constrain.
+    for (var rule in _rulesToHarden) {
+      _hardenRule(rule);
+    }
+
     // For each independent set of chunks, see if there are any rules in them
     // that we want to preemptively harden. This is basically to send smaller
     // batches of chunks to LineSplitter in cases where the code is deeply
     // nested or complex.
     var start = 0;
     for (var i = 0; i < _chunks.length; i++) {
       if (_canDivideAt(i)) {
         _preemptRules(start, i);
         start = i;
       }
@@ skipping 102 matching lines @@
   /// Hardens the active rules when a hard split occurs within them.
   void _handleHardSplit() {
     if (_rules.isEmpty) return;
 
     // If the current rule doesn't care, it will "eat" the hard split and no
     // others will care either.
     if (!_rules.last.splitsOnInnerRules) return;
 
     // Start with the innermost rule. This will traverse the other rules it
     // constrains.
-    _hardenRule(_rules.last);
+    _rulesToHarden.add(_rules.last);
   }
 
   /// Replaces [rule] with a hard split.
   ///
   /// This also applies all of the implications of that change:
   ///
   /// * Existing chunks using that rule are hardened.
   /// * Later chunks using that rule will use a hard split instead.
   /// * Any other rules that are constrained by this one are also hardened.
   void _hardenRule(Rule rule) {
@@ skipping 23 matching lines @@
         if (rule.constrain(rule.fullySplitValue, other) ==
             other.fullySplitValue) {
           harden(other);
         }
       }
     }
 
     harden(rule);
   }
 }