Don't allow inline block comments to eat pending newlines.

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 'line_splitter.dart';
 import 'line_writer.dart';
@@ skipping 14 matching lines @@
 
   /// The builder for the code surrounding the block that this writer is for, or
   /// `null` if this is writing the top-level code.
   final ChunkBuilder _parent;
 
   final SourceCode _source;
 
   final List<Chunk> _chunks;
 
   /// The whitespace that should be written to [_chunks] before the next
-  ///  non-whitespace token or `null` if no whitespace is pending.
+  ///  non-whitespace token.
   ///
   /// This ensures that changes to indentation and nesting also apply to the
   /// most recent split, even if the visitor "creates" the split before changing
   /// indentation or nesting.
-  Whitespace _pendingWhitespace;
+  Whitespace _pendingWhitespace = Whitespace.none;
 
   /// The nested stack of rules that are currently in use.
   ///
   /// New chunks are implicitly split by the innermost rule when the chunk is
   /// ended.
   final _rules = <Rule>[];
 
   /// The list of rules that are waiting until the next whitespace has been
   /// written before they start.
   final _lazyRules = <Rule>[];
@@ skipping 87 matching lines @@
   Chunk split({int nesting, bool space, bool flushLeft}) =>
       _writeSplit(_rules.last,
           nesting: nesting, flushLeft: flushLeft, 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 number of lines between the last comment (or
+  /// [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) {
     // 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
     //
@@ skipping 10 matching lines @@
       } else {
         for (var i = 1; i < comments.length; i++) {
           if (comments[i].linesBefore > 1) {
             _pendingWhitespace = Whitespace.newline;
             break;
           }
         }
       }
     }
 
+    // Corner case: if the comments are completely inline (i.e. just a series
+    // of block comments with no newlines before, after, or between them), then
+    // they will eat any pending newlines. Make sure that doesn't happen by
+    // putting the pending whitespace before the first comment and moving them
+    // to their own line. Turns this:
+    //
+    //     library foo; /* a */ /* b */ import 'a.dart';
+    //
+    // into:
+    //
+    //     library foo;
+    //
+    //     /* a */ /* b */
+    //     import 'a.dart';
+    if (linesBeforeToken == 0 &&
+        comments.every((comment) => comment.isInline)) {
+      if (_pendingWhitespace.minimumLines > 0) {
+        comments.first.linesBefore = _pendingWhitespace.minimumLines;
+        linesBeforeToken = 1;
+      }
+    }
+
     // Write each comment and the whitespace between them.
     for (var i = 0; i < comments.length; i++) {
       var comment = comments[i];
 
       preserveNewlines(comment.linesBefore);
 
       // Don't emit a space because we'll handle it below. If we emit it here,
       // we may get a trailing space if the comment needs a line before it.
-      if (_pendingWhitespace == Whitespace.space) _pendingWhitespace = null;
+      if (_pendingWhitespace == Whitespace.space) {
+        _pendingWhitespace = Whitespace.none;
+      }
       _emitPendingWhitespace();
 
       if (comment.linesBefore == 0) {
         // If we're sitting on a split, move the comment before it to adhere it
         // to the preceding text.
         if (_shouldMoveCommentBeforeSplit()) {
           _chunks.last.allowText();
         }
 
         // The comment follows other text, so we need to decide if it gets a
@@ skipping 287 matching lines @@
         isCompilationUnit: _source.isCompilationUnit,
         selectionStart: selectionStart,
         selectionLength: selectionLength);
   }
 
   /// Writes the current pending [Whitespace] to the output, if any.
   ///
   /// This should only be called after source lines have been preserved to turn
   /// any ambiguous whitespace into a concrete choice.
   void _emitPendingWhitespace() {
-    if (_pendingWhitespace == null) return;
     // Output any pending whitespace first now that we know it won't be
     // trailing.
     switch (_pendingWhitespace) {
       case Whitespace.space:
         _writeText(" ");
         break;
 
       case Whitespace.newline:
         _writeHardSplit();
         break;
@@ skipping 10 matching lines @@
         _writeHardSplit(double: true);
         break;
 
       case Whitespace.spaceOrNewline:
       case Whitespace.oneOrTwoNewlines:
         // We should have pinned these down before getting here.
         assert(false);
         break;
     }
 
-    _pendingWhitespace = null;
+    _pendingWhitespace = Whitespace.none;
   }
 
   /// Returns `true` if the last chunk is a split that should be move after the
   /// comment that is about to be written.
   bool _shouldMoveCommentBeforeSplit() {
     // Not if there is nothing before it.
     if (_chunks.isEmpty) return false;
 
     // If the text before the split is an open grouping character, we don't
     // want to adhere the comment to that.
@@ skipping 283 matching lines @@
         if (rule.constrain(rule.fullySplitValue, other) ==
             other.fullySplitValue) {
           harden(other);
         }
       }
     }
 
     harden(rule);
   }
 }