gn: start of format command

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 56 matching lines @@
   {&Parser::Group, NULL, -1},                                   // LEFT_PAREN
   {NULL, NULL, -1},                                             // RIGHT_PAREN
   {&Parser::List, &Parser::Subscript, PRECEDENCE_CALL},         // LEFT_BRACKET
   {NULL, NULL, -1},                                             // RIGHT_BRACKET
   {NULL, NULL, -1},                                             // LEFT_BRACE
   {NULL, NULL, -1},                                             // RIGHT_BRACE
   {NULL, NULL, -1},                                             // IF
   {NULL, NULL, -1},                                             // ELSE
   {&Parser::Name, &Parser::IdentifierOrCall, PRECEDENCE_CALL},  // IDENTIFIER
   {NULL, NULL, -1},                                             // COMMA
-  {NULL, NULL, -1},  // UNCLASSIFIED_COMMENT
-  {NULL, NULL, -1},  // LINE_COMMENT
-  {NULL, NULL, -1},  // SUFFIX_COMMENT
+  {NULL, NULL, -1},                   // UNCLASSIFIED_COMMENT
+  {NULL, NULL, -1},                   // LINE_COMMENT
+  {NULL, NULL, -1},                   // SUFFIX_COMMENT
+  {&Parser::BlockComment, NULL, -1},  // BLOCK_COMMENT
 };
 
 Parser::Parser(const std::vector<Token>& tokens, Err* err)
     : err_(err), cur_(0) {
   for (std::vector<Token>::const_iterator i(tokens.begin()); i != tokens.end();
        ++i) {
     switch(i->type()) {
       case Token::LINE_COMMENT:
         line_comment_tokens_.push_back(*i);
         break;
       case Token::SUFFIX_COMMENT:
         suffix_comment_tokens_.push_back(*i);
         break;
       default:
+        // Note that BLOCK_COMMENTs (top-level standalone comments) are passed
+        // through the real parser.
         tokens_.push_back(*i);
         break;
     }
   }
 }
 
 Parser::~Parser() {
 }
 
 // static
@@ skipping 119 matching lines @@
 }
 
 scoped_ptr<ParseNode> Parser::Literal(Token token) {
   return scoped_ptr<ParseNode>(new LiteralNode(token)).Pass();
 }
 
 scoped_ptr<ParseNode> Parser::Name(Token token) {
   return IdentifierOrCall(scoped_ptr<ParseNode>(), token).Pass();
 }
 
+scoped_ptr<ParseNode> Parser::BlockComment(Token token) {
+  scoped_ptr<BlockCommentNode> comment(new BlockCommentNode());
+  comment->set_comment(token);
+  return comment.PassAs<ParseNode>();
+}
+
 scoped_ptr<ParseNode> Parser::Group(Token token) {
   scoped_ptr<ParseNode> expr = ParseExpression();
   if (has_error())
     return scoped_ptr<ParseNode>();
   Consume(Token::RIGHT_PAREN, "Expected ')'");
   return expr.Pass();
 }
 
 scoped_ptr<ParseNode> Parser::Not(Token token) {
   scoped_ptr<ParseNode> expr = ParseExpression(PRECEDENCE_PREFIX + 1);
   if (has_error())
     return scoped_ptr<ParseNode>();
   scoped_ptr<UnaryOpNode> unary_op(new UnaryOpNode);
   unary_op->set_op(token);
   unary_op->set_operand(expr.Pass());
   return unary_op.PassAs<ParseNode>();
 }
 
 scoped_ptr<ParseNode> Parser::List(Token node) {
-  scoped_ptr<ParseNode> list(ParseList(Token::RIGHT_BRACKET, true));
+  scoped_ptr<ParseNode> list(ParseList(node, Token::RIGHT_BRACKET, true));
   if (!has_error() && !at_end())
     Consume(Token::RIGHT_BRACKET, "Expected ']'");
   return list.Pass();
 }
 
 scoped_ptr<ParseNode> Parser::BinaryOperator(scoped_ptr<ParseNode> left,
                                              Token token) {
   scoped_ptr<ParseNode> right =
       ParseExpression(expressions_[token.type()].precedence + 1);
   if (!right) {
     *err_ =
         Err(token,
             "Expected right hand side for '" + token.value().as_string() + "'");
     return scoped_ptr<ParseNode>();
   }
   scoped_ptr<BinaryOpNode> binary_op(new BinaryOpNode);
   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);
   scoped_ptr<BlockNode> block;
   bool has_arg = false;
-  if (Match(Token::LEFT_PAREN)) {
+  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(Token::RIGHT_PAREN, false);
+      list = ParseList(start_token, Token::RIGHT_PAREN, false);
       if (has_error())
         return scoped_ptr<ParseNode>();
       Consume(Token::RIGHT_PAREN, "Expected ')' after call");
     }
     // Optionally with a scope.
     if (LookAhead(Token::LEFT_BRACE)) {
       block = ParseBlock();
       if (has_error())
         return scoped_ptr<ParseNode>();
     }
@@ skipping 62 matching lines @@
   }
 
   scoped_ptr<AccessorNode> accessor(new AccessorNode);
   accessor->set_base(left->AsIdentifier()->value());
   accessor->set_member(scoped_ptr<IdentifierNode>(
       static_cast<IdentifierNode*>(right.release())));
   return accessor.PassAs<ParseNode>();
 }
 
 // Does not Consume the start or end token.
-scoped_ptr<ListNode> Parser::ParseList(Token::Type stop_before,
+scoped_ptr<ListNode> Parser::ParseList(Token start_token,
+                                       Token::Type stop_before,
                                        bool allow_trailing_comma) {
   scoped_ptr<ListNode> list(new ListNode);
-  list->set_begin_token(cur_token());
+  list->set_begin_token(start_token);
   bool just_got_comma = false;
   bool first_time = true;
   while (!LookAhead(stop_before)) {
     if (!first_time) {
       if (!just_got_comma) {
         // Require commas separate things in lists.
         *err_ = Err(cur_token(), "Expected comma between items.");
         return scoped_ptr<ListNode>();
       }
     }
     first_time = false;
 
     // Why _OR? We're parsing things that are higher precedence than the ,
     // that separates the items of the list. , should appear lower than
     // boolean expressions (the lowest of which is OR), but above assignments.
     list->append_item(ParseExpression(PRECEDENCE_OR));
     if (has_error())
       return scoped_ptr<ListNode>();
     if (at_end()) {
       *err_ =
           Err(tokens_[tokens_.size() - 1], "Unexpected end of file in list.");
       return scoped_ptr<ListNode>();
     }
-    just_got_comma = Match(Token::COMMA);
+    if (list->contents().back()->AsBlockComment()) {
+      // If there was a comment inside the list, we don't need a comma to the
+      // 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());
   return list.Pass();
 }
 
 scoped_ptr<ParseNode> Parser::ParseFile() {
@@ skipping 18 matching lines @@
   AssignComments(file.get());
 
   return file.PassAs<ParseNode>();
 }
 
 scoped_ptr<ParseNode> Parser::ParseStatement() {
   if (LookAhead(Token::LEFT_BRACE)) {
     return ParseBlock().PassAs<ParseNode>();
   } else if (LookAhead(Token::IF)) {
     return ParseCondition();
+  } else if (LookAhead(Token::BLOCK_COMMENT)) {
+    return BlockComment(Consume());
   } else {
     // TODO(scottmg): Is this too strict? Just drop all the testing if we want
     // to allow "pointless" expressions and return ParseExpression() directly.
     scoped_ptr<ParseNode> stmt = ParseExpression();
     if (stmt) {
       if (stmt->AsFunctionCall() || IsAssignment(stmt.get()))
         return stmt.Pass();
     }
     if (!has_error()) {
       Token token = at_end() ? tokens_[tokens_.size() - 1] : cur_token();
@@ skipping 73 matching lines @@
       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);
       }
     } else if (root->AsLiteral()) {
       // Nothing.
     } else if (const UnaryOpNode* unaryop = root->AsUnaryOp()) {
       TraverseOrder(unaryop->operand(), pre, post);
+    } else if (root->AsBlockComment()) {
+      // 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 55 matching lines @@
       } 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();
   }
 }