gn format: fix comments at end of blocks

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 "tools/gn/commands.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parser.h"
@@ skipping 32 matching lines @@
   void Block(const ParseNode* file);
 
   std::string String() const { return output_; }
 
  private:
   // Format a list of values using the given style.
   enum SequenceStyle {
     kSequenceStyleFunctionCall,
     kSequenceStyleList,
     kSequenceStyleBlock,
+    kSequenceStyleBracedBlock,
   };
 
   enum ExprStyle {
     kExprStyleRegular,
     kExprStyleComment,
   };
 
   // Add to output.
   void Print(base::StringPiece str);
 
   // Add the current margin (as spaces) to the output.
   void PrintMargin();
 
   void TrimAndPrintToken(const Token& token);
 
   // End the current line, flushing end of line comments.
   void Newline();
 
   // Remove trailing spaces from the current line.
   void Trim();
 
   // Get the 0-based x position on the current line.
   int CurrentColumn();
 
   // Print the expression to the output buffer. Returns the type of element
   // added to the output.
   ExprStyle Expr(const ParseNode* root);
 
+  // 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);
+  void Sequence(SequenceStyle style,
+                const std::vector<PARSENODE*>& list,
+                const ParseNode* end);
 
   std::string output_;           // Output buffer.
   std::vector<Token> comments_;  // Pending end-of-line comments.
   int margin_;                   // Left margin (number of spaces).
 
   DISALLOW_COPY_AND_ASSIGN(Printer);
 };
 
 Printer::Printer() : margin_(0) {
   output_.reserve(100 << 10);
@@ skipping 110 matching lines @@
     Print("TODO(scottmg): AccessorNode");
   } else if (const BinaryOpNode* binop = root->AsBinaryOp()) {
     // TODO(scottmg): Lots to do here for complex if expressions: reflowing,
     // parenthesizing, etc.
     Expr(binop->left());
     Print(" ");
     Print(binop->op().value());
     Print(" ");
     Expr(binop->right());
   } else if (const BlockNode* block = root->AsBlock()) {
-    Sequence(kSequenceStyleBlock, block->statements());
+    Sequence(kSequenceStyleBracedBlock, block->statements(), block->End());
   } else if (const ConditionNode* condition = root->AsConditionNode()) {
     Print("if (");
     Expr(condition->condition());
-    Print(") {");
-    margin_ += kIndentSize;
-    Newline();
-    Block(condition->if_true());
-    margin_ -= kIndentSize;
-    Trim();
-    PrintMargin();
-    Print("}");
+    Print(") ");
+    Sequence(kSequenceStyleBracedBlock,
+             condition->if_true()->statements(),
+             condition->if_true()->End());
     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());
       } else {
-        Print("{");
-        margin_ += kIndentSize;
-        Newline();
-        Block(condition->if_false());
-        margin_ -= kIndentSize;
-        Trim();
-        PrintMargin();
-        Print("}");
+        Sequence(kSequenceStyleBracedBlock,
+                 condition->if_false()->AsBlock()->statements(),
+                 condition->if_false()->AsBlock()->End());
       }
     }
   } else if (const FunctionCallNode* func_call = root->AsFunctionCall()) {
     Print(func_call->function().value());
-    Sequence(kSequenceStyleFunctionCall, func_call->args()->contents());
-    Print(" {");
-    margin_ += kIndentSize;
-    Newline();
-    Block(func_call->block());
-    margin_ -= kIndentSize;
-    Trim();
-    PrintMargin();
-    Print("}");
+    Sequence(kSequenceStyleFunctionCall,
+             func_call->args()->contents(),
+             func_call->args()->End());
+    Print(" ");
+    Sequence(kSequenceStyleBracedBlock,
+             func_call->block()->statements(),
+             func_call->block()->End());
   } else if (const IdentifierNode* identifier = root->AsIdentifier()) {
     Print(identifier->value().value());
   } else if (const ListNode* list = root->AsList()) {
-    Sequence(kSequenceStyleList, list->contents());
+    Sequence(kSequenceStyleList, list->contents(), list->End());
   } else if (const LiteralNode* literal = root->AsLiteral()) {
     // TODO(scottmg): Quoting?
     Print(literal->value().value());
   } else if (const UnaryOpNode* unaryop = root->AsUnaryOp()) {
     Print(unaryop->op().value());
     Expr(unaryop->operand());
   } else if (const BlockCommentNode* block_comment = root->AsBlockComment()) {
     Print(block_comment->comment().value());
     result = kExprStyleComment;
+  } else if (const EndNode* end = root->AsEnd()) {
+    Print(end->value().value());
   } else {
     CHECK(false) << "Unhandled case in Expr.";
   }
 
   // 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_));
   }
 
   return result;
 }
 
 template <class PARSENODE>
 void Printer::Sequence(SequenceStyle style,
-                       const std::vector<PARSENODE*>& list) {
+                       const std::vector<PARSENODE*>& list,
+                       const ParseNode* end) {
   bool force_multiline = false;
   if (style == kSequenceStyleFunctionCall)
     Print("(");
   else if (style == kSequenceStyleList)
     Print("[");
+  else if (style == kSequenceStyleBracedBlock)
+    Print("{");
 
-  if (style == kSequenceStyleBlock)
+  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;
   }
 
   if (list.size() == 0 && !force_multiline) {
     // No elements, and not forcing newlines, print nothing.
   } else if (list.size() == 1 && !force_multiline) {
     if (style != kSequenceStyleFunctionCall)
       Print(" ");
     Expr(list[0]);
-    CHECK(list[0]->comments()->after().empty());
+    CHECK(!list[0]->comments() || list[0]->comments()->after().empty());
     if (style != kSequenceStyleFunctionCall)
       Print(" ");
   } else {
     margin_ += kIndentSize;
     size_t i = 0;
     for (const auto& x : list) {
       Newline();
       ExprStyle expr_style = Expr(x);
-      CHECK(x->comments()->after().empty());
+      CHECK(!x->comments() || x->comments()->after().empty());
       if (i < list.size() - 1 || style == kSequenceStyleList) {
-        if (expr_style == kExprStyleRegular)
+        if ((style == kSequenceStyleList || kSequenceStyleFunctionCall) &&
+            expr_style == kExprStyleRegular) {
           Print(",");
-        else
+        } else {
           Newline();
+        }
       }
       ++i;
     }
 
+    // Trailing comments.
+    if (end->comments()) {
+      if (!list.empty())
+        Newline();
+      for (const auto& c : end->comments()->before()) {
+        Newline();
+        TrimAndPrintToken(c);
+      }
+    }
+
     margin_ -= kIndentSize;
     Newline();
   }
 
   if (style == kSequenceStyleFunctionCall)
     Print(")");
   else if (style == kSequenceStyleList)
     Print("]");
+  else if (style == kSequenceStyleBracedBlock)
+    Print("}");
 }
 
 }  // namespace
 
 bool FormatFileToString(const std::string& input_filename,
                         bool dump_tree,
                         std::string* output) {
   Setup setup;
   Err err;
   SourceFile input_file(input_filename);
@@ skipping 40 matching lines @@
   }
   std::string output_string;
   if (FormatFileToString(input_name, dump_tree, &output_string)) {
     printf("%s", output_string.c_str());
   }
 
   return 0;
 }
 
 }  // namespace commands