gn format: fix some cases of too many blank lines between items

tools/gn/command_format.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <sstream>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/strings/string_split.h"
 #include "tools/gn/commands.h"
@@ skipping 95 matching lines @@
 
   // End the current line, flushing end of line comments.
   void Newline();
 
   // Remove trailing spaces from the current line.
   void Trim();
 
   // Whether there's a blank separator line at the current position.
   bool HaveBlankLine();
 
+  bool IsAssignment(const ParseNode* node);
+
+  // Heuristics to decide if there should be a blank line added between two
+  // items. For various "small" items, it doesn't look nice if there's too much
+  // vertical whitespace added.
+  bool ShouldAddBlankLineInBetween(const ParseNode* a, const ParseNode* b);
+
   // Get the 0-based x position on the current line.
   int CurrentColumn();
 
   // Adds an opening ( if prec is less than the outers (to maintain evalution
   // order for a subexpression). If an opening paren is emitted, *parenthesized
   // will be set so it can be closed at the end of the expression.
   void AddParen(int prec, int outer_prec, bool* parenthesized);
 
   // Print the expression to the output buffer. Returns the type of element
   // added to the output. The value of outer_prec gives the precedence of the
@@ skipping 94 matching lines @@
   output_.resize(n);
 }
 
 bool Printer::HaveBlankLine() {
   size_t n = output_.size();
   while (n > 0 && output_[n - 1] == ' ')
     --n;
   return n > 2 && output_[n - 1] == '\n' && output_[n - 2] == '\n';
 }
 
+bool Printer::IsAssignment(const ParseNode* node) {
+  return node->AsBinaryOp() && (node->AsBinaryOp()->op().value() == "=" ||
+                                node->AsBinaryOp()->op().value() == "+=" ||
+                                node->AsBinaryOp()->op().value() == "-=");
+}
+
+bool Printer::ShouldAddBlankLineInBetween(const ParseNode* a,
+                                          const ParseNode* b) {
+  // A bunch of imports looks silly at the top of a file separated by blank
+  // lines, even though they are statements.
+  if (a->AsFunctionCall() && b->AsFunctionCall() &&
+      a->AsFunctionCall()->function().value() == "import" &&
+      b->AsFunctionCall()->function().value() == "import") {
+    return false;
+  }
+
+  if (IsAssignment(a) && IsAssignment(b)) {
+    Metrics first = GetLengthOfExpr(a, kPrecedenceLowest);
+    Metrics second = GetLengthOfExpr(b, kPrecedenceLowest);
+    if (!first.multiline && !second.multiline)
+      return false;
+  }
+  return true;
+}
+
 int Printer::CurrentColumn() {
   int n = 0;
   while (n < static_cast<int>(output_.size()) &&
          output_[output_.size() - 1 - n] != '\n') {
     ++n;
   }
   return n;
 }
 
 void Printer::Block(const ParseNode* root) {
@@ skipping 14 matching lines @@
       // Why are before() not printed here too? before() are handled inside
       // Expr(), as are suffix() which are queued to the next Newline().
       // However, because it's a general expression handler, it doesn't insert
       // the newline itself, which only happens between block statements. So,
       // the after are handled explicitly here.
       for (const auto& c : stmt->comments()->after()) {
         TrimAndPrintToken(c);
         Newline();
       }
     }
-    if (i < block->statements().size() - 1)
+    if (i < block->statements().size() - 1 &&
+        (ShouldAddBlankLineInBetween(block->statements()[i],
+                                     block->statements()[i + 1]))) {
       Newline();
+    }
     ++i;
   }
 
   if (block->comments()) {
     for (const auto& c : block->comments()->after()) {
       TrimAndPrintToken(c);
       Newline();
     }
   }
 }
@@ skipping 448 matching lines @@
       printf("Wrote formatted to '%s'.\n", to_write.AsUTF8Unsafe().c_str());
     } else {
       printf("%s", output_string.c_str());
     }
   }
 
   return 0;
 }
 
 }  // namespace commands