gn format: don't break+indent if it's going to be forced past 80col anyway

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 127 matching lines @@
 
   // 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
   // operator outside this Expr. If that operator binds tighter than root's,
   // Expr must introduce parentheses.
   int Expr(const ParseNode* root, int outer_prec, const std::string& suffix);
 
   // Generic penalties for exceeding maximum width, adding more lines, etc.
   int AssessPenalty(const std::string& output);
 
+  // Tests if any lines exceed the maximum width.
+  bool ExceedsMaximumWidth(const std::string& output);
+
   // 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.
@@ skipping 209 matching lines @@
   std::vector<std::string> lines;
   base::SplitStringDontTrim(output, '\n', &lines);
   penalty += static_cast<int>(lines.size() - 1) * GetPenaltyForLineBreak();
   for (const auto& line : lines) {
     if (line.size() > kMaximumWidth)
       penalty += static_cast<int>(line.size() - kMaximumWidth) * kPenaltyExcess;
   }
   return penalty;
 }
 
+bool Printer::ExceedsMaximumWidth(const std::string& output) {
+  std::vector<std::string> lines;
+  base::SplitStringDontTrim(output, '\n', &lines);
+  for (const auto& line : lines) {
+    if (line.size() > kMaximumWidth)
+      return true;
+  }
+  return false;
+}
+
 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) {
@@ skipping 103 matching lines @@
 
     // Break after operator.
     Printer sub2;
     InitializeSub(&sub2);
     sub2.Newline();
     int penalty_next_line =
         sub2.Expr(binop->right(), prec_right, std::string());
     sub2.Print(suffix);
     penalty_next_line += AssessPenalty(sub2.String());
 
-    if (penalty_current_line < penalty_next_line) {
+    // If in both cases it was forced past 80col, then we don't break to avoid
+    // breaking after '=' in the case of:
+    //   variable = "... very long string ..."
+    // as breaking and indenting doesn't make things much more readable, even
+    // though there's less characters past the maximum width.
+    bool exceeds_maximum_either_way = ExceedsMaximumWidth(sub1.String()) &&
+                                      ExceedsMaximumWidth(sub2.String());
+
+    if (penalty_current_line < penalty_next_line ||
+        exceeds_maximum_either_way) {
       Print(" ");
       Expr(binop->right(), prec_right, std::string());
     } else {
       // Otherwise, put first argument and op, and indent next.
       Newline();
       penalty += std::abs(CurrentColumn() - start_column) *
                  kPenaltyHorizontalSeparation;
       Expr(binop->right(), prec_right, std::string());
     }
     stack_.pop_back();
@@ skipping 472 matching lines @@
       }
     } else {
       printf("%s", output_string.c_str());
     }
   }
 
   return 0;
 }
 
 }  // namespace commands