Change the way hard splits are handled.

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_writer.dart';
@@ skipping 343 matching lines @@
     var openSpan = _openSpans.removeLast();
 
     // A span that just covers a single chunk can't be split anyway.
     var end = _currentChunkIndex;
     if (openSpan.start == end) return;
 
     // Add the span to every chunk that can split it.
     var span = new Span(openSpan.cost);
     for (var i = openSpan.start; i < end; i++) {
       var chunk = _chunks[i];
-      if (!chunk.isHardSplit) chunk.spans.add(span);
+      if (!chunk.rule.isHardened) chunk.spans.add(span);
     }
   }
 
   /// Starts a new [Rule].
   ///
-  /// If omitted, defaults to a new [SimpleRule].
+  /// If omitted, defaults to a new [Rule].
   void startRule([Rule rule]) {
-    if (rule == null) rule = new SimpleRule();
+    if (rule == null) rule = new Rule();
 
     // See if any of the rules that contain this one care if it splits.
     _rules.forEach((outer) => outer.contain(rule));
     _rules.add(rule);
   }
 
   /// Starts a new [Rule] that comes into play *after* the next whitespace
   /// (including comments) is written.
   ///
   /// This is used for binary operators who want to start a rule before the
   /// first operand but not get forced to split if a comment appears before the
   /// entire expression.
   ///
-  /// If [rule] is omitted, defaults to a new [SimpleRule].
+  /// If [rule] is omitted, defaults to a new [Rule].
   void startLazyRule([Rule rule]) {
-    if (rule == null) rule = new SimpleRule();
+    if (rule == null) rule = new Rule();
 
     _lazyRules.add(rule);
   }
 
   /// Ends the innermost rule.
   void endRule() {
     _rules.removeLast();
   }
 
   /// Pre-emptively forces all of the current rules to become hard splits.
@@ skipping 84 matching lines @@
 
   /// Ends this [ChunkBuilder], which must have been created by [startBlock()].
   ///
   /// Forces the chunk that owns the block to split if it can tell that the
   /// block contents will always split. It does that by looking for hard splits
   /// in the block. If [ignoredSplit] is given, that rule will be ignored
   /// when determining if a block contains a hard split. If [forceSplit] is
   /// `true`, the block is considered to always split.
   ///
   /// Returns the previous writer for the surrounding block.
-  ChunkBuilder endBlock(HardSplitRule ignoredSplit, {bool forceSplit}) {
+  ChunkBuilder endBlock(Rule ignoredSplit, {bool forceSplit}) {
     _divideChunks();
 
     // If we don't already know if the block is going to split, see if it
     // contains any hard splits or is longer than a page.
     if (!forceSplit) {
       var length = 0;
       for (var chunk in _chunks) {
         length += chunk.length + chunk.unsplitBlockLength;
         if (length > _formatter.pageWidth) {
           forceSplit = true;
           break;
         }
 
-        if (chunk.isHardSplit && chunk.rule != ignoredSplit) {
+        if (chunk.rule != null &&
+            chunk.rule.isHardened &&
+            chunk.rule != ignoredSplit) {
           forceSplit = true;
           break;
         }
       }
     }
 
     _parent._endChildBlock(
         firstFlushLeft: _firstFlushLeft, forceSplit: forceSplit);
 
     return _parent;
@@ skipping 157 matching lines @@
   ///
   /// If [double] is `true` or `false`, forces a single or double line to be
   /// output. Otherwise, it is left indeterminate.
   ///
   /// If [flushLeft] is `true`, then the split will always cause the next line
   /// to be at column zero. Otherwise, it uses the normal indentation and
   /// nesting behavior.
   void _writeHardSplit({bool isDouble, bool flushLeft, bool nest: false}) {
     // A hard split overrides any other whitespace.
     _pendingWhitespace = null;
-    _writeSplit(new HardSplitRule(),
+    _writeSplit(new Rule.hard(),
         flushLeft: flushLeft, isDouble: isDouble, nest: nest);
   }
 
   /// Ends the current chunk (if any) with the given split information.
   ///
   /// Returns the chunk.
   Chunk _writeSplit(Rule rule,
       {bool flushLeft, bool isDouble, bool nest, bool space}) {
     if (nest == null) nest = true;
 
     if (_chunks.isEmpty) {
       if (flushLeft != null) _firstFlushLeft = flushLeft;
 
       return null;
     }
 
     _chunks.last.applySplit(rule, _nesting.indentation,
         nest ? _nesting.nesting : new NestingLevel(),
         flushLeft: flushLeft, isDouble: isDouble, space: space);
 
     return _afterSplit();
   }
 
   /// Keep tracks of which chunks are owned by which rules and handles hard
   /// splits after a chunk has been completed.
   Chunk _afterSplit() {
     var chunk = _chunks.last;
 
-    if (chunk.rule is! HardSplitRule) {
+    if (_rules.isNotEmpty) {
       _ruleChunks.putIfAbsent(rule, () => []).add(_chunks.length - 1);
     }
 
-    if (chunk.isHardSplit) _handleHardSplit();
+    if (chunk.rule.isHardened) _handleHardSplit();
 
     return chunk;
   }
 
   /// Writes [text] to either the current chunk or a new one if the current
   /// chunk is complete.
   void _writeText(String text) {
     if (_chunks.isNotEmpty && _chunks.last.canAddText) {
       _chunks.last.appendText(text);
     } else {
       _chunks.add(new Chunk(text));
     }
   }
 
   /// Returns true if we can divide the chunks at [index] and line split the
   /// ones before and after that separately.
   bool _canDivideAt(int i) {
+    // Don't divide after the last chunk.
+    if (i == _chunks.length - 1) return false;
+
     var chunk = _chunks[i];
-    if (!chunk.isHardSplit) return false;
+    if (!chunk.rule.isHardened) return false;
     if (chunk.nesting.isNested) return false;
     if (chunk.isBlock) return false;
 
     // Make sure we don't split the line in the middle of a rule.
     var chunks = _ruleChunks[chunk.rule];
     if (chunks != null && chunks.any((other) => other > i)) return false;
 
     return true;
   }
 
@@ skipping 27 matching lines @@
     _hardSplitRules.add(_rules.last);
   }
 
   /// Replaces all of the previously hardened rules with hard splits, along
   /// with every rule that those constrain to also split.
   ///
   /// This should only be called after all chunks have been written.
   void _hardenRules() {
     if (_hardSplitRules.isEmpty) return;
 
-    // Harden all of the rules that are constrained by [rules] as well.
-    var hardenedRules = new Set();
     walkConstraints(rule) {
-      if (hardenedRules.contains(rule)) return;
-      hardenedRules.add(rule);
+      rule.harden();
 
       // Follow this rule's constraints, recursively.
       for (var other in _ruleChunks.keys) {
         if (other == rule) continue;
 
-        if (rule.constrain(rule.fullySplitValue, other) ==
-            other.fullySplitValue) {
+        if (!other.isHardened &&
+            rule.constrain(rule.fullySplitValue, other) ==
+                other.fullySplitValue) {
           walkConstraints(other);
         }
       }
     }
 
     for (var rule in _hardSplitRules) {
       walkConstraints(rule);
     }
 
-    // Harden every chunk that uses one of these rules.
+    // Discard spans in hardened chunks since we know for certain they will
+    // split anyway.
     for (var chunk in _chunks) {
-      if (hardenedRules.contains(chunk.rule)) {
-        chunk.harden();
+      if (chunk.rule != null && chunk.rule.isHardened) {
+        chunk.spans.clear();
       }
     }
   }
 }