Tweak formatting rules. Fix #211.

lib/src/line_writer.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.source_writer;
 
 import 'dart_formatter.dart';
 import 'chunk.dart';
 import 'debug.dart';
 import 'line_splitter.dart';
@@ skipping 56 matching lines @@
   ///
   /// Collections can also contain function expressions, which have blocks which
   /// in turn force a newline in the middle of the collection. When that
   /// happens, we need to force all surrounding collections to be multi-line.
   /// This tracks them so we can do that.
   final _multisplits = <Multisplit>[];
 
   /// The nested stack of spans that are currently being written.
   final _openSpans = <Span>[];
 
-  /// All of the spans that have been created, open and closed.
+  /// All of the spans that have been created and closed.
   final _spans = <Span>[];
 
   /// The current indentation and nesting levels.
   ///
   /// This is tracked as a stack of numbers. Each element in the stack
   /// represents a level of statement indentation. The number of the element is
   /// the current expression nesting depth for that statement.
   ///
   /// It's stored as a stack because expressions may contain statements which
   /// in turn contain other expressions. The nesting level of the inner
@@ skipping 276 matching lines @@
   /// Starts a new span with [cost].
   ///
   /// Each call to this needs a later matching call to [endSpan].
   void startSpan([int cost = Cost.normal]) {
     _openSpans.add(new Span(_currentChunkIndex, cost));
   }
 
   /// Ends the innermost span.
   void endSpan() {
     var span = _openSpans.removeLast();
+
+    // If the span was discarded while it was still open, just forget about it.
+    if (span == null) return;
+
     span.close(_currentChunkIndex);
 
     // A span that just covers a single chunk can't be split anyway.
     if (span.start == span.end) return;
     _spans.add(span);
   }
 
   /// Starts a new [Multisplit].
   ///
   /// Returns the [SplitParam] for the multisplit.
-  SplitParam startMultisplit({bool separable}) {
-    var multisplit = new Multisplit(_currentChunkIndex, separable: separable);
+  SplitParam startMultisplit({bool separable, int cost}) {
+    var multisplit = new Multisplit(_currentChunkIndex,
+        separable: separable, cost: cost);
     _multisplits.add(multisplit);
 
     return multisplit.param;
   }
 
   /// Adds a new split point for the current innermost [Multisplit].
   ///
   /// If [space] is `true`, the chunk will include a space when unsplit. If
   /// [nest] is `true`, then this split will take into account expression
   /// nesting. Otherwise, it will not. Collections do not follow expression
@@ skipping 20 matching lines @@
   /// Pre-emptively forces all of the multisplits to become hard splits.
   ///
   /// This is called by [SourceVisitor] when it can determine that a multisplit
   /// will never be satisfied. Turning it into hard splits lets the writer
   /// break the output into smaller pieces for the line splitter, which helps
   /// performance and avoids failing on very large input.
   ///
   /// In particular, it's easy for the visitor to know that collections with a
   /// large number of items must split. Doing that early avoids crashing the
   /// splitter when it tries to recurse on huge collection literals.
-  void preemptMultisplits() => _splitMultisplits();
+  void preemptMultisplits() => _handleHardSplit();
 
   /// Increases the level of expression nesting.
   ///
   /// Expressions that are more nested will get increased indentation when split
   /// if the previous line has a lower level of nesting.
   void nestExpression() {
     if (_pendingNesting != null) {
       _pendingNesting++;
     } else {
       _pendingNesting = _nesting + 1;
@@ skipping 178 matching lines @@
   }
 
   /// Ends the current chunk (if any) with the given split information.
   void _writeSplit(int indent, int nesting, SplitParam param,
       {bool isDouble, bool spaceWhenUnsplit}) {
     if (_chunks.isEmpty) return;
 
     _chunks.last.applySplit(indent, nesting, param,
         isDouble: isDouble, spaceWhenUnsplit: spaceWhenUnsplit);
 
-    if (_chunks.last.isHardSplit) _splitMultisplits();
+    if (_chunks.last.isHardSplit) _handleHardSplit();
   }
 
   /// Writes [text] to either the current chunk or a new one if the current
   /// chunk is complete.
   void _writeText(String text) {
     if (_chunks.isEmpty) {
       _chunks.add(new Chunk(text));
     } else if (_chunks.last.canAddText) {
       _chunks.last.appendText(text);
     } else {
@@ skipping 34 matching lines @@
     _beginningIndent = split.indent;
 
     return true;
   }
 
   /// Hands off the first [length] chunks to the [LineSplitter] as a single
   /// logical line to be split.
   void _completeLine(int length) {
     assert(_chunks.isNotEmpty);
 
-    if (debugFormatter) {
-      dumpChunks(_chunks.take(length).toList());
-      print(_spans.join("\n"));
-    }
-
     // Write the newlines required by the previous line.
     for (var i = 0; i < _bufferedNewlines; i++) {
       _buffer.write(_formatter.lineEnding);
     }
 
     // If we aren't completing the entire set of chunks, get the subset that we
     // are completing.
     var chunks = _chunks;
     var spans = _spans;
 
     if (length < _chunks.length) {
       chunks = chunks.take(length).toList();
       spans = spans.where((span) => span.start <= length).toList();
     }
 
+    if (debugFormatter) {
+      dumpChunks(chunks);
+      print(spans.join("\n"));
+    }
+
     var splitter = new LineSplitter(_formatter.lineEnding, _formatter.pageWidth,
         chunks, spans, _beginningIndent);
     var selection = splitter.apply(_buffer);
 
     if (selection[0] != null) _selectionStart = selection[0];
     if (selection[1] != null) _selectionLength = selection[1] - _selectionStart;
   }
 
-  /// Handles multisplits when a hard line occurs.
+  /// Handles open multisplits and spans when a hard line occurs.
   ///
   /// Any active separable multisplits will get split in two at this point.
   /// Other multisplits are forced into the "hard" state. All of their previous
   /// splits are turned into explicit hard splits and any new splits for that
   /// multisplit become hard splits too.
-  void _splitMultisplits() {
+  ///
+  /// All open spans get discarded since they will never be satisfied.
+  void _handleHardSplit() {
+    // Discard all open spans. We don't remove them from the stack so that we
+    // can still correctly count later calls to endSpan().
+    for (var i = 0; i < _openSpans.length; i++) {
+      _openSpans[i] = null;
+    }
+
     if (_multisplits.isEmpty) return;
 
     var splitParams = new Set();
 
     // Add [param] and the transitive closure of its implied params to
     // [splitParams].
     traverseParams(param) {
       splitParams.add(param);
 
       // Traverse the tree of implied params.
@@ skipping 22 matching lines @@
         // the loop counter.
         if (_checkForCompleteLine(i + 1)) i = -1;
       } else {
         // If the chunk isn't hardened, but implies something that is, we can
         // discard the implication since it is always satisfied now.
         chunk.param.implies.removeWhere(splitParams.contains);
       }
     }
   }
 }