gn format: penalty-based line breaking WIP XXX

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"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file.h"
+#include "tools/gn/line_breaker.h"
 #include "tools/gn/parser.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/tokenizer.h"
 
 namespace commands {
 
 const char kSwitchDumpTree[] = "dump-tree";
 const char kSwitchInPlace[] = "in-place";
@@ skipping 23 matching lines @@
     "      --in-place of course.\n"
     "\n"
     "Examples\n"
     "  gn format //some/BUILD.gn\n"
     "  gn format some\\BUILD.gn\n"
     "  gn format /abspath/some/BUILD.gn\n"
     "  gn format --stdin\n";
 
 namespace {
 
-const int kIndentSize = 2;
-const int kMaximumWidth = 80;
-
-enum Precedence {
-  kPrecedenceLowest,
-  kPrecedenceAssign,
-  kPrecedenceOr,
-  kPrecedenceAnd,
-  kPrecedenceCompare,
-  kPrecedenceAdd,
-  kPrecedenceSuffix,
-  kPrecedenceUnary,
-};
-
 class Printer {
  public:
   Printer();
   ~Printer();
 
   void Block(const ParseNode* file);
 
   std::string String() const { return output_; }
 
  private:
@@ skipping 67 matching lines @@
   // |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);
 
   void FunctionCall(const FunctionCallNode* func_call);
 
+  bool IsStartOfStatement(const ParseNode* node);
+
   std::string output_;           // Output buffer.
   std::vector<Token> comments_;  // Pending end-of-line comments.
   int margin_;                   // Left margin (number of spaces).
 
-  // Gives the precedence for operators in a BinaryOpNode.
-  std::map<base::StringPiece, Precedence> precedence_;
-
   DISALLOW_COPY_AND_ASSIGN(Printer);
 };
 
 Printer::Printer() : margin_(0) {
   output_.reserve(100 << 10);
-  precedence_["="] = kPrecedenceAssign;
-  precedence_["+="] = kPrecedenceAssign;
-  precedence_["-="] = kPrecedenceAssign;
-  precedence_["||"] = kPrecedenceOr;
-  precedence_["&&"] = kPrecedenceAnd;
-  precedence_["<"] = kPrecedenceCompare;
-  precedence_[">"] = kPrecedenceCompare;
-  precedence_["=="] = kPrecedenceCompare;
-  precedence_["!="] = kPrecedenceCompare;
-  precedence_["<="] = kPrecedenceCompare;
-  precedence_[">="] = kPrecedenceCompare;
-  precedence_["+"] = kPrecedenceAdd;
-  precedence_["-"] = kPrecedenceAdd;
-  precedence_["!"] = kPrecedenceUnary;
 }
 
 Printer::~Printer() {
 }
 
 void Printer::Print(base::StringPiece str) {
   str.AppendToString(&output_);
 }
 
 void Printer::PrintMargin() {
@@ skipping 87 matching lines @@
 
   if (block->comments()) {
     for (const auto& c : block->comments()->before()) {
       TrimAndPrintToken(c);
       Newline();
     }
   }
 
   size_t i = 0;
   for (const auto& stmt : block->statements()) {
+    std::stringstream tmp;
+    stmt->Print(tmp, 0);
+    fprintf(stderr, "stmt: %s\n", tmp.str().c_str());
     Expr(stmt, kPrecedenceLowest, false);
     Newline();
     if (stmt->comments()) {
       // 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);
@@ skipping 33 matching lines @@
   return result;
 }
 
 void Printer::AddParen(int prec, int outer_prec, bool* parenthesized) {
   if (prec < outer_prec) {
     Print("(");
     *parenthesized = true;
   }
 }
 
+// This determines if the given node is something "statement-like". Generally
+// these are an assignment like 'sources = ["x"]' or a standalone function call
+// like 'import("xyz.gni")'. Some cases are slightly involved because the parse
+// tree is generic across binary operators which include both assignments that
+// are standalone statements, but also operators link &&, || which are not.
+// Additionally, function calls can mark statement boundaries when they're a
+// statement inside a block, but they may also be embedded for their return
+// value into the body of an expression (say, a rebase_path() in an expression).
+//
+// TODO: Maybe all the above is overly complicated, and it's just all the
+// direct children of BlockNodes + the false branch of ConditionNode.
+//
+// Breaking up into statements is used to segment into chunks. Line breaking and
+// indenting is done on a chunk basis, and one chunk does not affect another.
+bool Printer::IsStartOfStatement(const ParseNode* node) {
+  // Is start of statement:
+  // AccessorNode;      // No
+  // BinaryOpNode;      // For =, +=, -=: Yes, else: No.
+  // BlockCommentNode;  // Yes
+  // BlockNode;         // No (?) just its statements.
+  // ConditionNode;     // Yes both arms.
+  // EndNode;           // No
+  // FunctionCallNode;  // Sometimes. This one is tricky. Maybe only when it's
+  //                    // the immediate child of a BlockNode?
+  // IdentifierNode;    // No
+  // ListNode;          // No
+  // LiteralNode;       // No
+  // UnaryOpNode;       // No
+  return false;
+}
+
+void DetermineLineBreaksForChunk() {
+}
+
 Printer::ExprStyle Printer::Expr(const ParseNode* root,
                                  int outer_prec,
                                  bool prefer_multiline) {
   ExprStyle result = kExprStyleRegular;
   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");
@@ skipping 14 matching lines @@
     if (accessor->member()) {
       Print(".");
       Expr(accessor->member(), kPrecedenceLowest, false);
     } else {
       CHECK(accessor->index());
       Print("[");
       Expr(accessor->index(), kPrecedenceLowest, false);
       Print("]");
     }
   } else if (const BinaryOpNode* binop = root->AsBinaryOp()) {
-    CHECK(precedence_.find(binop->op().value()) != precedence_.end());
-    Precedence prec = precedence_[binop->op().value()];
+    Precedence prec = GetPrecedence(binop->op().value());
     AddParen(prec, outer_prec, &parenthesized);
+    //FindLineBreakLocation(binop);
     Metrics right = GetLengthOfExpr(
         binop->right(), prec + 1, IsAlwaysMultilineAssignment(binop));
     int op_length = static_cast<int>(binop->op().value().size()) + 2;
     Expr(binop->left(), prec, false);
     if (CurrentColumn() + op_length + right.first_length <= kMaximumWidth) {
       // If it just fits normally, put it here.
       Print(" ");
       Print(binop->op().value());
       Print(" ");
       Expr(binop->right(), prec + 1, IsAlwaysMultilineAssignment(binop));
@@ skipping 17 matching lines @@
     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) {
+std::stringstream tmp;
+condition->if_false()->Print(tmp, 0);
+fprintf(stderr, "stmt4: %s\n", tmp.str().c_str());
         Expr(condition->if_false(), kPrecedenceLowest, false);
       } else {
         Sequence(kSequenceStyleBracedBlock,
                  condition->if_false()->AsBlock()->statements(),
                  condition->if_false()->AsBlock()->End(),
                  false);
       }
     }
   } else if (const FunctionCallNode* func_call = root->AsFunctionCall()) {
     FunctionCall(func_call);
@@ skipping 50 matching lines @@
   // 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;
   }
 
   if (list.size() == 0 && !force_multiline) {
     // No elements, and not forcing newlines, print nothing.
   } else if (list.size() == 1 && !force_multiline) {
     Print(" ");
+if (style == kSequenceStyleBracedBlock) {
+std::stringstream tmp;
+list[0]->Print(tmp, 0);
+fprintf(stderr, "stmt2: %s\n", tmp.str().c_str());
+}
     Expr(list[0], kPrecedenceLowest, false);
     CHECK(!list[0]->comments() || list[0]->comments()->after().empty());
     Print(" ");
   } else {
     margin_ += kIndentSize;
     size_t i = 0;
     for (const auto& x : list) {
+if (style == kSequenceStyleBracedBlock) {
+std::stringstream tmp;
+x->Print(tmp, 0);
+fprintf(stderr, "stmt3: %s\n", tmp.str().c_str());
+}
       Newline();
       // If:
       // - we're going to output some comments, and;
       // - we haven't just started this multiline list, and;
       // - there isn't already a blank line here;
       // Then: insert one.
       if (i != 0 && x->comments() && !x->comments()->before().empty() &&
           !HaveBlankLine()) {
         Newline();
       }
@@ skipping 289 matching lines @@
       printf("Wrote formatted to '%s'.\n", to_write.AsUTF8Unsafe().c_str());
     } else {
       printf("%s", output_string.c_str());
     }
   }
 
   return 0;
 }
 
 }  // namespace commands