gn format: Fix and enable a few more tests

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/files/file_util.h"
 #include "base/strings/string_split.h"
 #include "tools/gn/commands.h"
@@ skipping 41 matching lines @@
     "  gn format --stdin\n";
 
 namespace {
 
 const int kIndentSize = 2;
 const int kMaximumWidth = 80;
 
 const int kPenaltyLineBreak = 500;
 const int kPenaltyHorizontalSeparation = 100;
 const int kPenaltyExcess = 10000;
-const int kPenaltyBrokenLineOnOneLiner = 1000;
+const int kPenaltyBrokenLineOnOneLiner = 5000;
 
 enum Precedence {
   kPrecedenceLowest,
   kPrecedenceAssign,
   kPrecedenceOr,
   kPrecedenceAnd,
   kPrecedenceCompare,
   kPrecedenceAdd,
   kPrecedenceSuffix,
   kPrecedenceUnary,
 };
 
+int CountLines(const std::string& str) {
+  std::vector<std::string> lines;
+  base::SplitStringDontTrim(str, '\n', &lines);
+  return lines.size();
+}
+
 class Printer {
  public:
   Printer();
   ~Printer();
 
   void Block(const ParseNode* file);
 
   std::string String() const { return output_; }
 
  private:
@@ skipping 59 matching lines @@
   // Format a list of values using the given style.
   // |end| holds any trailing comments to be printed just before the closing
   // bracket.
   template <class PARSENODE>  // Just for const covariance.
   void Sequence(SequenceStyle style,
                 const std::vector<PARSENODE*>& list,
                 const ParseNode* end,
                 bool force_multiline);
 
   // Returns the penalty.
-  int FunctionCall(const FunctionCallNode* func_call);
+  int FunctionCall(const FunctionCallNode* func_call,
+                   const std::string& suffix);
 
   // Create a clone of this Printer in a similar state (other than the output,
   // but including margins, etc.) to be used for dry run measurements.
   void InitializeSub(Printer* sub);
 
+  template <class PARSENODE>
+  bool ListWillBeMultiline(const std::vector<PARSENODE*>& list,
+                           const ParseNode* end);
+
   std::string output_;           // Output buffer.
   std::vector<Token> comments_;  // Pending end-of-line comments.
   int margin() const { return stack_.back().margin; }
 
   int penalty_depth_;
   int GetPenaltyForLineBreak() const {
     return penalty_depth_ * kPenaltyLineBreak;
   }
 
   struct IndentState {
@@ skipping 190 matching lines @@
 void Printer::AddParen(int prec, int outer_prec, bool* parenthesized) {
   if (prec < outer_prec) {
     Print("(");
     *parenthesized = true;
   }
 }
 
 int Printer::Expr(const ParseNode* root,
                   int outer_prec,
                   const std::string& suffix) {
+  std::string at_end = suffix;
   int penalty = 0;
   penalty_depth_++;
 
   if (root->comments()) {
     if (!root->comments()->before().empty()) {
       Trim();
       // If there's already other text on the line, start a new line.
       if (CurrentColumn() > 0)
         Print("\n");
       // We're printing a line comment, so we need to be at the current margin.
@@ skipping 18 matching lines @@
       Print("[");
       Expr(accessor->index(), kPrecedenceLowest, "]");
     }
   } else if (const BinaryOpNode* binop = root->AsBinaryOp()) {
     CHECK(precedence_.find(binop->op().value()) != precedence_.end());
     AnnotatePreferedMultilineAssignment(binop);
     Precedence prec = precedence_[binop->op().value()];
     AddParen(prec, outer_prec, &parenthesized);
     int start_line = CurrentLine();
     int start_column = CurrentColumn();
+    bool is_assignment = binop->op().value() == "=" ||
+                         binop->op().value() == "+=" ||
+                         binop->op().value() == "-=";
+    // A sort of funny special case for the long lists that are common in .gn
+    // files, don't indent them + 4, even though they're just continuations when
+    // they're simple lists like "x = [ a, b, c, ... ]"
+    const ListNode* right_as_list = binop->right()->AsList();
     int indent_column =
-        (binop->op().value() == "=" || binop->op().value() == "+=" ||
-         binop->op().value() == "-=")
+        (is_assignment &&
+         (!right_as_list || (!right_as_list->prefer_multiline() &&
+                             !ListWillBeMultiline(right_as_list->contents(),
+                                                  right_as_list->End()))))
             ? margin() + kIndentSize * 2
             : start_column;
     if (stack_.back().continuation_requires_indent)
       indent_column += kIndentSize * 2;
 
-    Expr(binop->left(),
-         prec,
-         std::string(" ") + binop->op().value().as_string());
+    Printer sub_left;
+    InitializeSub(&sub_left);
+    sub_left.Expr(binop->left(),
+                  prec,
+                  std::string(" ") + binop->op().value().as_string());
+    bool left_is_multiline = CountLines(sub_left.String()) > 1;
+    // Avoid walking the whole left redundantly times (see timing of Format.046)
+    // so pull the output and comments from subprinter.
+    Print(sub_left.String().substr(start_column));
+    std::copy(sub_left.comments_.begin(),
+              sub_left.comments_.end(),
+              std::back_inserter(comments_));
 
     // Single line.
     Printer sub1;
     InitializeSub(&sub1);
     sub1.stack_.push_back(IndentState(indent_column, false));
     sub1.Print(" ");
     int penalty_current_line =
         sub1.Expr(binop->right(), prec + 1, std::string());
     sub1.Print(suffix);
     penalty_current_line += AssessPenalty(sub1.String());
+    if (!is_assignment && left_is_multiline) {
+      // In e.g. xxx + yyy, if xxx is already multiline, then we want a penalty
+      // for trying to continue as if this were one line.
+      penalty_current_line +=
+          (CountLines(sub1.String()) - 1) * kPenaltyBrokenLineOnOneLiner;
+    }
 
     // Break after operator.
     Printer sub2;
     InitializeSub(&sub2);
     sub2.stack_.push_back(IndentState(indent_column, false));
     sub2.Newline();
     int penalty_next_line = sub2.Expr(binop->right(), prec + 1, std::string());
     sub2.Print(suffix);
     penalty_next_line += AssessPenalty(sub2.String());
 
+    stack_.push_back(IndentState(indent_column, false));
     if (penalty_current_line < penalty_next_line) {
       Print(" ");
       Expr(binop->right(), prec + 1, std::string());
     } else {
       // Otherwise, put first argument and op, and indent next.
-      stack_.push_back(IndentState(indent_column, false));
       Newline();
       penalty += std::abs(CurrentColumn() - start_column) *
                  kPenaltyHorizontalSeparation;
       Expr(binop->right(), prec + 1, std::string());
-      stack_.pop_back();
     }
+    stack_.pop_back();
     penalty += (CurrentLine() - start_line) * GetPenaltyForLineBreak();
   } else if (const BlockNode* block = root->AsBlock()) {
     Sequence(
         kSequenceStyleBracedBlock, block->statements(), block->End(), false);
   } else if (const ConditionNode* condition = root->AsConditionNode()) {
     Print("if (");
     // TODO(scottmg): The { needs to be included in the suffix here.
     Expr(condition->condition(), kPrecedenceLowest, ") ");
     Sequence(kSequenceStyleBracedBlock,
              condition->if_true()->statements(),
              condition->if_true()->End(),
              false);
     if (condition->if_false()) {
       Print(" else ");
       // If it's a block it's a bare 'else', otherwise it's an 'else if'. See
       // ConditionNode::Execute.
       bool is_else_if = condition->if_false()->AsBlock() == NULL;
       if (is_else_if) {
         Expr(condition->if_false(), kPrecedenceLowest, std::string());
       } else {
         Sequence(kSequenceStyleBracedBlock,
                  condition->if_false()->AsBlock()->statements(),
-                 condition->if_false()->AsBlock()->End(), false);
+                 condition->if_false()->AsBlock()->End(),
+                 false);
       }
     }
   } else if (const FunctionCallNode* func_call = root->AsFunctionCall()) {
-    penalty += FunctionCall(func_call);
+    penalty += FunctionCall(func_call, at_end);
+    at_end = "";
   } else if (const IdentifierNode* identifier = root->AsIdentifier()) {
     Print(identifier->value().value());
   } else if (const ListNode* list = root->AsList()) {
     bool force_multiline =
         list->prefer_multiline() && !list->contents().empty();
     Sequence(
         kSequenceStyleList, list->contents(), list->End(), force_multiline);
   } else if (const LiteralNode* literal = root->AsLiteral()) {
     Print(literal->value().value());
   } else if (const UnaryOpNode* unaryop = root->AsUnaryOp()) {
@@ skipping 10 matching lines @@
   if (parenthesized)
     Print(")");
 
   // Defer any end of line comment until we reach the newline.
   if (root->comments() && !root->comments()->suffix().empty()) {
     std::copy(root->comments()->suffix().begin(),
               root->comments()->suffix().end(),
               std::back_inserter(comments_));
   }
 
-  Print(suffix);
+  Print(at_end);
 
   penalty_depth_--;
   return penalty;
 }
 
 template <class PARSENODE>
 void Printer::Sequence(SequenceStyle style,
                        const std::vector<PARSENODE*>& list,
                        const ParseNode* end,
                        bool force_multiline) {
   if (style == kSequenceStyleList)
     Print("[");
   else if (style == kSequenceStyleBracedBlock)
     Print("{");
 
   if (style == kSequenceStyleBlock || style == kSequenceStyleBracedBlock)
     force_multiline = true;
 
-  if (end && end->comments() && !end->comments()->before().empty())
-    force_multiline = true;
-
-  // If there's before line comments, make sure we have a place to put them.
-  for (const auto& i : list) {
-    if (i->comments() && !i->comments()->before().empty())
-      force_multiline = true;
-  }
+  force_multiline |= ListWillBeMultiline(list, end);
 
   if (list.size() == 0 && !force_multiline) {
     // No elements, and not forcing newlines, print nothing.
   } else if (list.size() == 1 && !force_multiline) {
     Print(" ");
     Expr(list[0], kPrecedenceLowest, std::string());
     CHECK(!list[0]->comments() || list[0]->comments()->after().empty());
     Print(" ");
   } else {
     stack_.push_back(
@@ skipping 19 matching lines @@
         if (!want_comma) {
           if (i < list.size() - 1 &&
               ShouldAddBlankLineInBetween(list[i], list[i + 1]))
             Newline();
         }
       }
       ++i;
     }
 
     // Trailing comments.
-    if (end->comments()) {
+    if (end->comments() && !end->comments()->before().empty()) {
       if (list.size() >= 2)
         Newline();
       for (const auto& c : end->comments()->before()) {
         Newline();
         TrimAndPrintToken(c);
       }
     }
 
     stack_.pop_back();
     Newline();
 
     // Defer any end of line comment until we reach the newline.
     if (end->comments() && !end->comments()->suffix().empty()) {
       std::copy(end->comments()->suffix().begin(),
         end->comments()->suffix().end(),
         std::back_inserter(comments_));
     }
   }
 
   if (style == kSequenceStyleList)
     Print("]");
   else if (style == kSequenceStyleBracedBlock)
     Print("}");
 }
 
-int Printer::FunctionCall(const FunctionCallNode* func_call) {
+int Printer::FunctionCall(const FunctionCallNode* func_call,
+                          const std::string& suffix) {
   int start_line = CurrentLine();
   int start_column = CurrentColumn();
   Print(func_call->function().value());
   Print("(");
 
   bool have_block = func_call->block() != nullptr;
   bool force_multiline = false;
 
   const std::vector<const ParseNode*>& list = func_call->args()->contents();
   const ParseNode* end = func_call->args()->End();
 
   if (end && end->comments() && !end->comments()->before().empty())
     force_multiline = true;
 
   // If there's before line comments, make sure we have a place to put them.
   for (const auto& i : list) {
     if (i->comments() && !i->comments()->before().empty())
       force_multiline = true;
   }
 
   // Calculate the penalties for 3 possible layouts:
   // 1. all on same line;
   // 2. starting on same line, broken at each comma but paren aligned;
   // 3. broken to next line + 4, broken at each comma.
   std::string terminator = ")";
   if (have_block)
     terminator += " {";
+  terminator += suffix;
 
   // 1: Same line.
   Printer sub1;
   InitializeSub(&sub1);
   sub1.stack_.push_back(IndentState(CurrentColumn(), true));
   int penalty_one_line = 0;
   for (size_t i = 0; i < list.size(); ++i) {
     penalty_one_line += sub1.Expr(list[i], kPrecedenceLowest,
                                   i < list.size() - 1 ? ", " : std::string());
   }
   sub1.Print(terminator);
   penalty_one_line += AssessPenalty(sub1.String());
-  std::vector<std::string> lines;
-  base::SplitStringDontTrim(sub1.String(), '\n', &lines);
   // This extra penalty prevents a short second argument from being squeezed in
   // after a first argument that went multiline (and instead preferring a
   // variant below).
-  if (lines.size() > 1)
-    penalty_one_line += kPenaltyBrokenLineOnOneLiner;
+  penalty_one_line +=
+      (CountLines(sub1.String()) - 1) * kPenaltyBrokenLineOnOneLiner;
 
   // 2: Starting on same line, broken at commas.
   Printer sub2;
   InitializeSub(&sub2);
   sub2.stack_.push_back(IndentState(CurrentColumn(), true));
   int penalty_multiline_start_same_line = 0;
   for (size_t i = 0; i < list.size(); ++i) {
     penalty_multiline_start_same_line += sub2.Expr(
         list[i], kPrecedenceLowest, i < list.size() - 1 ? "," : std::string());
     if (i < list.size() - 1) {
@@ skipping 78 matching lines @@
     stack_.pop_back();
   }
 
   // Defer any end of line comment until we reach the newline.
   if (end->comments() && !end->comments()->suffix().empty()) {
     std::copy(end->comments()->suffix().begin(),
               end->comments()->suffix().end(), std::back_inserter(comments_));
   }
 
   Print(")");
+  Print(suffix);
 
   if (have_block) {
     Print(" ");
     Sequence(kSequenceStyleBracedBlock,
              func_call->block()->statements(),
              func_call->block()->End(),
              false);
   }
   return penalty + (CurrentLine() - start_line) * GetPenaltyForLineBreak();
 }
 
 void Printer::InitializeSub(Printer* sub) {
   sub->stack_ = stack_;
   sub->comments_ = comments_;
   sub->penalty_depth_ = penalty_depth_;
   sub->Print(std::string(CurrentColumn(), 'x'));
 }
 
+template <class PARSENODE>
+bool Printer::ListWillBeMultiline(const std::vector<PARSENODE*>& list,
+                                  const ParseNode* end) {
+  if (list.size() > 1)
+    return true;
+
+  if (end && end->comments() && !end->comments()->before().empty())
+    return true;
+
+  // If there's before line comments, make sure we have a place to put them.
+  for (const auto& i : list) {
+    if (i->comments() && !i->comments()->before().empty())
+      return true;
+  }
+
+  return false;
+}
+
 void DoFormat(const ParseNode* root, bool dump_tree, std::string* output) {
   if (dump_tree) {
     std::ostringstream os;
     root->Print(os, 0);
     printf("----------------------\n");
     printf("-- PARSE TREE --------\n");
     printf("----------------------\n");
     printf("%s", os.str().c_str());
     printf("----------------------\n");
   }
@@ skipping 114 matching lines @@
       printf("Wrote formatted to '%s'.\n", to_write.AsUTF8Unsafe().c_str());
     } else {
       printf("%s", output_string.c_str());
     }
   }
 
   return 0;
 }
 
 }  // namespace commands