Eat some dogfood!

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 73 matching lines @@
   bool _firstFlushLeft = false;
 
   /// Whether there is pending whitespace that depends on the number of
   /// newlines in the source.
   ///
   /// This is used to avoid calculating the newlines between tokens unless
   /// actually needed since doing so is slow when done between every single
   /// token pair.
   bool get needsToPreserveNewlines =>
       _pendingWhitespace == Whitespace.oneOrTwoNewlines ||
-      _pendingWhitespace == Whitespace.spaceOrNewline;
+          _pendingWhitespace == Whitespace.spaceOrNewline;
 
   /// The number of characters of code that can fit in a single line.
   int get pageWidth => _formatter.pageWidth;
 
   /// The current innermost rule.
   Rule get rule => _rules.last;
 
   ChunkBuilder(this._formatter, this._source)
       : _parent = null,
         _chunks = [] {
@@ skipping 36 matching lines @@
   /// Write a split owned by the current innermost rule.
   ///
   /// If [nesting] is given, uses that. Otherwise, uses the current nesting
   /// level. If unsplit, it expands to a space if [space] is `true`.
   ///
   /// If [flushLeft] is `true`, then forces the next line to start at column
   /// one regardless of any indentation or nesting.
   ///
   /// If [isDouble] is passed, forces the split to either be a single or double
   /// newline. Otherwise, leaves it indeterminate.
-  Chunk split({bool space, bool isDouble, bool flushLeft}) =>
-      _writeSplit(_rules.last, null,
-          flushLeft: flushLeft, isDouble: isDouble, spaceWhenUnsplit: space);
+  Chunk split({bool space, bool isDouble, bool flushLeft}) => _writeSplit(
+      _rules.last, null,
+      flushLeft: flushLeft, isDouble: isDouble, spaceWhenUnsplit: space);
 
   /// Write a split owned by the current innermost rule.
   ///
   /// Unlike [split()], this ignores any current expression nesting. It always
   /// indents the next line at the statement level.
-  Chunk blockSplit({bool space, bool isDouble}) =>
-      _writeSplit(_rules.last, _nesting.blockNesting,
-          isDouble: isDouble,
-          spaceWhenUnsplit: space);
+  Chunk blockSplit({bool space, bool isDouble}) => _writeSplit(
+      _rules.last, _nesting.blockNesting,
+      isDouble: isDouble, spaceWhenUnsplit: space);
 
   /// Outputs the series of [comments] and associated whitespace that appear
   /// before [token] (which is not written by this).
   ///
   /// The list contains each comment as it appeared in the source between the
   /// last token written and the next one that's about to be written.
   ///
   /// [linesBeforeToken] is the number of lines between the last comment (or
   /// previous token if there are no comments) and the next token.
-  void writeComments(List<SourceComment> comments, int linesBeforeToken,
-      String token) {
+  void writeComments(
+      List<SourceComment> comments, int linesBeforeToken, String token) {
     // Corner case: if we require a blank line, but there exists one between
     // some of the comments, or after the last one, then we don't need to
     // enforce one before the first comment. Example:
     //
     //     library foo;
     //     // comment
     //
     //     class Bar {}
     //
     // Normally, a blank line is required after `library`, but since there is
@@ skipping 56 matching lines @@
           _chunks.last.allowText();
         }
 
         // The comment follows other text, so we need to decide if it gets a
         // space before it or not.
         if (_needsSpaceBeforeComment(isLineComment: comment.isLineComment)) {
           _writeText(" ");
         }
       } else {
         // The comment starts a line, so make sure it stays on its own line.
-        _writeHardSplit(nest: true, flushLeft: comment.flushLeft,
+        _writeHardSplit(
+            nest: true,
+            flushLeft: comment.flushLeft,
             double: comment.linesBefore > 1);
       }
 
       _writeText(comment.text);
 
       if (comment.selectionStart != null) {
         startSelectionFromEnd(comment.text.length - comment.selectionStart);
       }
 
       if (comment.selectionEnd != null) {
@@ skipping 192 matching lines @@
 
   /// Releases the last nesting level captured by [startBlockArgumentNesting].
   void endBlockArgumentNesting() {
     _blockArgumentNesting.removeLast();
   }
 
   /// Starts a new block as a child of the current chunk.
   ///
   /// Nested blocks are handled using their own independent [LineWriter].
   ChunkBuilder startBlock() {
-    var builder = new ChunkBuilder._(this, _formatter, _source,
-        _chunks.last.blockChunks);
+    var builder =
+        new ChunkBuilder._(this, _formatter, _source, _chunks.last.blockChunks);
 
     // A block always starts off indented one level.
     builder.indent();
 
     return builder;
   }
 
   /// 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
@@ skipping 161 matching lines @@
   /// was just written and the token that will be written.
   bool _needsSpaceAfterLastComment(List<SourceComment> comments, String token) {
     // Not if there are no comments.
     if (comments.isEmpty) return false;
 
     // Not at the beginning of a line.
     if (!_chunks.last.canAddText) return false;
 
     // Otherwise, it gets a space if the following token is not a delimiter or
     // the empty string, for EOF.
-    return token != ")" && token != "]" && token != "}" &&
-           token != "," && token != ";" && token != "";
+    return token != ")" &&
+        token != "]" &&
+        token != "}" &&
+        token != "," &&
+        token != ";" &&
+        token != "";
   }
 
   /// Appends a hard split with the current indentation and nesting (the latter
   /// only if [nest] is `true`).
   ///
   /// If [double] is `true` or `false`, forces a since 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
@@ skipping 224 matching lines @@
         if (rule.constrain(rule.fullySplitValue, other) ==
             other.fullySplitValue) {
           harden(other);
         }
       }
     }
 
     harden(rule);
   }
 }