Change the way hard splits are handled.

lib/src/chunk.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;
 
 import 'fast_hash.dart';
 import 'nesting_level.dart';
 import 'rule/rule.dart';
 
@@ skipping 96 matching lines @@
   /// called, no more text should be added to the chunk since it would appear
   /// *before* the split.
   bool get canAddText => _rule == null;
 
   /// The [Rule] that controls when a split should occur after this chunk.
   ///
   /// Multiple splits may share a [Rule].
   Rule get rule => _rule;
   Rule _rule;
 
-  /// Whether this chunk is always followed by a newline or whether the line
-  /// splitter may choose to keep the next chunk on the same line.
-  bool get isHardSplit => _rule is HardSplitRule;
-
   /// Whether or not an extra blank line should be output after this chunk if
   /// it's split.
   ///
   /// Internally, this can be either `true`, `false`, or `null`. The latter is
   /// an indeterminate state that lets later modifications to the split decide
   /// whether it should be double or not.
   ///
   /// However, this getter does not expose that. It will return `false` if the
   /// chunk is still indeterminate.
   bool get isDouble => _isDouble != null ? _isDouble : false;
@@ skipping 59 matching lines @@
   void allowText() {
     _rule = null;
   }
 
   /// Append [text] to the end of the split's text.
   void appendText(String text) {
     assert(canAddText);
     _text += text;
   }
 
-  /// Forces this soft split to become a hard split.
-  ///
-  /// This is called on the soft splits owned by a rule that decides to harden
-  /// when it finds out another hard split occurs within its chunks.
-  void harden() {
-    _rule = new HardSplitRule();
-    spans.clear();
-  }
-
   /// Finishes off this chunk with the given [rule] and split information.
   ///
   /// This may be called multiple times on the same split since the splits
   /// produced by walking the source and the splits coming from comments and
   /// preserved whitespace often overlap. When that happens, this has logic to
   /// combine that information into a single split.
   void applySplit(Rule rule, int indent, NestingLevel nesting,
       {bool flushLeft, bool isDouble, bool space}) {
     if (flushLeft == null) flushLeft = false;
     if (space == null) space = false;
-    if (isHardSplit || rule is HardSplitRule) {
+    if (rule.isHardened) {
       // A hard split always wins.
       _rule = rule;
     } else if (_rule == null) {
       // If the chunk hasn't been initialized yet, just inherit the rule.
       _rule = rule;
     }
 
     // Last split settings win.
     _flushLeft = flushLeft;
     _nesting = nesting;
@@ skipping 34 matching lines @@
 
     if (text.isNotEmpty) parts.add(text);
 
     if (_indent != null) parts.add("indent:$_indent");
     if (spaceWhenUnsplit == true) parts.add("space");
     if (_isDouble == true) parts.add("double");
     if (_flushLeft == true) parts.add("flush");
 
     if (_rule == null) {
       parts.add("(no split)");
-    } else if (isHardSplit) {
-      parts.add("hard");
     } else {
       parts.add(rule.toString());
+      if (rule.isHardened) parts.add("(hard)");
 
       if (_rule.constrainedRules.isNotEmpty) {
         parts.add("-> ${_rule.constrainedRules.join(' ')}");
       }
     }
 
     return parts.join(" ");
   }
 }
 
@@ skipping 115 matching lines @@
   /// output. This way, commented out chunks of code do not get erroneously
   /// re-indented.
   final bool flushLeft;
 
   /// Whether this comment is an inline block comment.
   bool get isInline => linesBefore == 0 && !isLineComment;
 
   SourceComment(this.text, this.linesBefore,
       {this.isLineComment, this.flushLeft});
 }