gn format: fix comments at end of blocks

tools/gn/parser.cc

 // Copyright (c) 2013 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 "tools/gn/parser.h"
 
 #include "base/logging.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/token.h"
@@ skipping 267 matching lines @@
   binary_op->set_op(token);
   binary_op->set_left(left.Pass());
   binary_op->set_right(right.Pass());
   return binary_op.PassAs<ParseNode>();
 }
 
 scoped_ptr<ParseNode> Parser::IdentifierOrCall(scoped_ptr<ParseNode> left,
                                                Token token) {
   scoped_ptr<ListNode> list(new ListNode);
   list->set_begin_token(token);
-  list->set_end_token(token);
+  list->set_end(make_scoped_ptr(new EndNode(token)));
   scoped_ptr<BlockNode> block;
   bool has_arg = false;
   if (LookAhead(Token::LEFT_PAREN)) {
     Token start_token = Consume();
     // Parsing a function call.
     has_arg = true;
     if (Match(Token::RIGHT_PAREN)) {
       // Nothing, just an empty call.
     } else {
       list = ParseList(start_token, Token::RIGHT_PAREN, false);
@@ skipping 112 matching lines @@
       // next item, so pretend we got one, if we're expecting one.
       just_got_comma = allow_trailing_comma;
     } else {
       just_got_comma = Match(Token::COMMA);
     }
   }
   if (just_got_comma && !allow_trailing_comma) {
     *err_ = Err(cur_token(), "Trailing comma");
     return scoped_ptr<ListNode>();
   }
-  list->set_end_token(cur_token());
+  list->set_end(make_scoped_ptr(new EndNode(cur_token())));
   return list.Pass();
 }
 
 scoped_ptr<ParseNode> Parser::ParseFile() {
   scoped_ptr<BlockNode> file(new BlockNode(false));
   for (;;) {
     if (at_end())
       break;
     scoped_ptr<ParseNode> statement = ParseStatement();
     if (!statement)
@@ skipping 40 matching lines @@
 scoped_ptr<BlockNode> Parser::ParseBlock() {
   Token begin_token =
       Consume(Token::LEFT_BRACE, "Expected '{' to start a block.");
   if (has_error())
     return scoped_ptr<BlockNode>();
   scoped_ptr<BlockNode> block(new BlockNode(true));
   block->set_begin_token(begin_token);
 
   for (;;) {
     if (LookAhead(Token::RIGHT_BRACE)) {
-      block->set_end_token(Consume());
+      block->set_end(make_scoped_ptr(new EndNode(Consume())));
       break;
     }
 
     scoped_ptr<ParseNode> statement = ParseStatement();
     if (!statement)
       return scoped_ptr<BlockNode>();
     block->append_statement(statement.Pass());
   }
   return block.Pass();
 }
@@ skipping 26 matching lines @@
     } else if (const BinaryOpNode* binop = root->AsBinaryOp()) {
       TraverseOrder(binop->left(), pre, post);
       TraverseOrder(binop->right(), pre, post);
     } else if (const BlockNode* block = root->AsBlock()) {
       const std::vector<ParseNode*>& statements = block->statements();
       for (std::vector<ParseNode*>::const_iterator i(statements.begin());
           i != statements.end();
           ++i) {
         TraverseOrder(*i, pre, post);
       }
+      TraverseOrder(block->End(), pre, post);
     } else if (const ConditionNode* condition = root->AsConditionNode()) {
       TraverseOrder(condition->condition(), pre, post);
       TraverseOrder(condition->if_true(), pre, post);
       TraverseOrder(condition->if_false(), pre, post);
     } else if (const FunctionCallNode* func_call = root->AsFunctionCall()) {
       TraverseOrder(func_call->args(), pre, post);
       TraverseOrder(func_call->block(), pre, post);
     } else if (root->AsIdentifier()) {
       // Nothing.
     } else if (const ListNode* list = root->AsList()) {
       const std::vector<const ParseNode*>& contents = list->contents();
       for (std::vector<const ParseNode*>::const_iterator i(contents.begin());
           i != contents.end();
           ++i) {
         TraverseOrder(*i, pre, post);
       }
+      TraverseOrder(list->End(), pre, post);
     } else if (root->AsLiteral()) {
       // Nothing.
     } else if (const UnaryOpNode* unaryop = root->AsUnaryOp()) {
       TraverseOrder(unaryop->operand(), pre, post);
     } else if (root->AsBlockComment()) {
       // Nothing.
+    } else if (root->AsEnd()) {
+      // Nothing.
     } else {
       CHECK(false) << "Unhandled case in TraverseOrder.";
     }
 
     post->push_back(root);
   }
 }
 
 void Parser::AssignComments(ParseNode* file) {
   // Start by generating a pre- and post- order traversal of the tree so we
@@ skipping 24 matching lines @@
        ++cur_comment)
     file->comments_mutable()->append_after(line_comment_tokens_[cur_comment]);
 
   // Assign suffix to syntax immediately before.
   cur_comment = static_cast<int>(suffix_comment_tokens_.size() - 1);
   for (std::vector<const ParseNode*>::const_reverse_iterator i = post.rbegin();
        i != post.rend();
        ++i) {
     // Don't assign suffix comments to the function call or list, but instead
     // to the last thing inside.
-    if ((*i)->AsFunctionCall() || (*i)->AsList())
+    if ((*i)->AsFunctionCall() || (*i)->AsList() || (*i)->AsEnd())
       continue;
 
     const Location& start = (*i)->GetRange().begin();
     const Location& end = (*i)->GetRange().end();
 
     // Don't assign suffix comments to something that starts on an earlier
     // line, so that in:
     //
     // sources = [ "a",
     //     "b" ] # comment
     //
     // it's attached to "b", not sources = [ ... ].
     if (start.line_number() != end.line_number())
       continue;
 
     while (cur_comment >= 0) {
       if (end.byte() <= suffix_comment_tokens_[cur_comment].location().byte()) {
         const_cast<ParseNode*>(*i)->comments_mutable()->append_suffix(
             suffix_comment_tokens_[cur_comment]);
         --cur_comment;
       } else {
         break;
       }
     }
 
     // Suffix comments were assigned in reverse, so if there were multiple on
     // the same node, they need to be reversed.
-    const_cast<ParseNode*>(*i)->comments_mutable()->ReverseSuffix();
+    if ((*i)->comments() && !(*i)->comments()->suffix().empty())
+      const_cast<ParseNode*>(*i)->comments_mutable()->ReverseSuffix();
   }
 }