Change the way hard splits are handled.

lib/src/rule/argument.dart

 // Copyright (c) 2015, 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.rule.argument;
 
 import '../chunk.dart';
 import 'rule.dart';
 
 /// Base class for a rule that handles argument or parameter lists.
@@ skipping 106 matching lines @@
   /// Creates a new rule for a positional argument list.
   ///
   /// If [collectionRule] is given, it is the rule used to split the
   /// collections in the list. If [splitsOnInnerRules] is `true`, then we will
   /// split before the argument if the argument itself contains a split.
   SinglePositionalRule(Rule collectionRule, {bool splitsOnInnerRules})
       : super(collectionRule),
         splitsOnInnerRules =
             splitsOnInnerRules != null ? splitsOnInnerRules : false;
 
-  bool isSplit(int value, Chunk chunk) => value != Rule.unsplit;
-
   int constrain(int value, Rule other) {
     var constrained = super.constrain(value, other);
     if (constrained != null) return constrained;
 
     if (other != _collectionRule) return null;
 
     // If we aren't splitting any args, we can split the collection.
     if (value == Rule.unsplit) return null;
 
     // We are splitting before a collection, so don't let it split internally.
@@ skipping 48 matching lines @@
 
     return result;
   }
 
   MultiplePositionalRule(
       Rule collectionRule, this._leadingCollections, this._trailingCollections)
       : super(collectionRule);
 
   String toString() => "*Pos${super.toString()}";
 
-  bool isSplit(int value, Chunk chunk) {
-    // Don't split at all.
-    if (value == Rule.unsplit) return false;
-
+  bool isSplitAtValue(int value, Chunk chunk) {
     // Split only before the first argument. Keep the entire argument list
     // together on the next line.
     if (value == 1) return chunk == _arguments.first;
 
     // Split before a single argument. Try later arguments before earlier ones
     // to try to keep as much on the first line as possible.
     if (value <= _arguments.length) {
       var argument = _arguments.length - value + 1;
       return chunk == _arguments[argument];
     }
@@ skipping 80 matching lines @@
   int get numValues => 3;
 
   NamedRule({bool containsCollections})
       : _containsCollections = containsCollections ?? false;
 
   void beforeArguments(Chunk chunk) {
     assert(_first == null);
     _first = chunk;
   }
 
-  bool isSplit(int value, Chunk chunk) {
-    switch (value) {
-      case Rule.unsplit:
-        return false;
-      case 1:
-        return chunk == _first;
-      case 2:
-        return true;
-    }
+  bool isSplitAtValue(int value, Chunk chunk) {
+    // Only split before the first argument.
+    if (value == 1) return chunk == _first;
 
-    throw "unreachable";
+    // Split before every argument.
+    return true;
   }
 
   String toString() => "Named${super.toString()}";
 }