Convert Pass()→std::move() in //tools

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 <utility>
+
 #include "base/logging.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/token.h"
 
 const char kGrammar_Help[] =
     "GN build language grammar\n"
     "\n"
     "Tokens\n"
     "\n"
@@ skipping 191 matching lines @@
 
 // static
 scoped_ptr<ParseNode> Parser::ParseExpression(const std::vector<Token>& tokens,
                                               Err* err) {
   Parser p(tokens, err);
   scoped_ptr<ParseNode> expr = p.ParseExpression();
   if (!p.at_end() && !err->has_error()) {
     *err = Err(p.cur_token(), "Trailing garbage");
     return nullptr;
   }
-  return expr.Pass();
+  return expr;
 }
 
 // static
 scoped_ptr<ParseNode> Parser::ParseValue(const std::vector<Token>& tokens,
                                          Err* err) {
   for (const Token& token : tokens) {
     switch (token.type()) {
       case Token::INTEGER:
       case Token::STRING:
       case Token::TRUE_TOKEN:
@@ skipping 92 matching lines @@
 
   if (prefix == nullptr) {
     *err_ = Err(token,
                 std::string("Unexpected token '") + token.value().as_string() +
                     std::string("'"));
     return scoped_ptr<ParseNode>();
   }
 
   scoped_ptr<ParseNode> left = (this->*prefix)(token);
   if (has_error())
-    return left.Pass();
+    return left;
 
   while (!at_end() && !IsStatementBreak(cur_token().type()) &&
          precedence <= expressions_[cur_token().type()].precedence) {
     token = Consume();
     InfixFunc infix = expressions_[token.type()].infix;
     if (infix == nullptr) {
       *err_ = Err(token,
                   std::string("Unexpected token '") +
                       token.value().as_string() + std::string("'"));
       return scoped_ptr<ParseNode>();
     }
-    left = (this->*infix)(left.Pass(), token);
+    left = (this->*infix)(std::move(left), token);
     if (has_error())
       return scoped_ptr<ParseNode>();
   }
 
-  return left.Pass();
+  return left;
 }
 
 scoped_ptr<ParseNode> Parser::Literal(Token token) {
   return make_scoped_ptr(new LiteralNode(token));
 }
 
 scoped_ptr<ParseNode> Parser::Name(Token token) {
-  return IdentifierOrCall(scoped_ptr<ParseNode>(), token).Pass();
+  return IdentifierOrCall(scoped_ptr<ParseNode>(), token);
 }
 
 scoped_ptr<ParseNode> Parser::BlockComment(Token token) {
   scoped_ptr<BlockCommentNode> comment(new BlockCommentNode());
   comment->set_comment(token);
-  return comment.Pass();
+  return std::move(comment);
 }
 
 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();
+  return expr;
 }
 
 scoped_ptr<ParseNode> Parser::Not(Token token) {
   scoped_ptr<ParseNode> expr = ParseExpression(PRECEDENCE_PREFIX + 1);
   if (has_error())
     return scoped_ptr<ParseNode>();
   if (!expr) {
     if (!has_error())
       *err_ = Err(token, "Expected right-hand side for '!'.");
     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.Pass();
+  unary_op->set_operand(std::move(expr));
+  return std::move(unary_op);
 }
 
 scoped_ptr<ParseNode> Parser::List(Token node) {
   scoped_ptr<ParseNode> list(ParseList(node, Token::RIGHT_BRACKET, true));
   if (!has_error() && !at_end())
     Consume(Token::RIGHT_BRACKET, "Expected ']'");
-  return list.Pass();
+  return list;
 }
 
 scoped_ptr<ParseNode> Parser::BinaryOperator(scoped_ptr<ParseNode> left,
                                              Token token) {
   scoped_ptr<ParseNode> right =
       ParseExpression(expressions_[token.type()].precedence + 1);
   if (!right) {
     if (!has_error()) {
       *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.Pass();
+  binary_op->set_left(std::move(left));
+  binary_op->set_right(std::move(right));
+  return std::move(binary_op);
 }
 
 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(make_scoped_ptr(new EndNode(token)));
   scoped_ptr<BlockNode> block;
   bool has_arg = false;
   if (LookAhead(Token::LEFT_PAREN)) {
@@ skipping 11 matching lines @@
     // Optionally with a scope.
     if (LookAhead(Token::LEFT_BRACE)) {
       block = ParseBlock();
       if (has_error())
         return scoped_ptr<ParseNode>();
     }
   }
 
   if (!left && !has_arg) {
     // Not a function call, just a standalone identifier.
-    return scoped_ptr<ParseNode>(new IdentifierNode(token)).Pass();
+    return scoped_ptr<ParseNode>(new IdentifierNode(token));
   }
   scoped_ptr<FunctionCallNode> func_call(new FunctionCallNode);
   func_call->set_function(token);
-  func_call->set_args(list.Pass());
+  func_call->set_args(std::move(list));
   if (block)
-    func_call->set_block(block.Pass());
-  return func_call.Pass();
+    func_call->set_block(std::move(block));
+  return std::move(func_call);
 }
 
 scoped_ptr<ParseNode> Parser::Assignment(scoped_ptr<ParseNode> left,
                                          Token token) {
   if (left->AsIdentifier() == nullptr) {
     *err_ = Err(left.get(), "Left-hand side of assignment must be identifier.");
     return scoped_ptr<ParseNode>();
   }
   scoped_ptr<ParseNode> value = ParseExpression(PRECEDENCE_ASSIGNMENT);
   if (!value) {
     if (!has_error())
       *err_ = Err(token, "Expected right-hand side for assignment.");
     return scoped_ptr<ParseNode>();
   }
   scoped_ptr<BinaryOpNode> assign(new BinaryOpNode);
   assign->set_op(token);
-  assign->set_left(left.Pass());
-  assign->set_right(value.Pass());
-  return assign.Pass();
+  assign->set_left(std::move(left));
+  assign->set_right(std::move(value));
+  return std::move(assign);
 }
 
 scoped_ptr<ParseNode> Parser::Subscript(scoped_ptr<ParseNode> left,
                                         Token token) {
   // TODO: Maybe support more complex expressions like a[0][0]. This would
   // require work on the evaluator too.
   if (left->AsIdentifier() == nullptr) {
     *err_ = Err(left.get(), "May only subscript identifiers.",
         "The thing on the left hand side of the [] must be an identifier\n"
         "and not an expression. If you need this, you'll have to assign the\n"
         "value to a temporary before subscripting. Sorry.");
     return scoped_ptr<ParseNode>();
   }
   scoped_ptr<ParseNode> value = ParseExpression();
   Consume(Token::RIGHT_BRACKET, "Expecting ']' after subscript.");
   scoped_ptr<AccessorNode> accessor(new AccessorNode);
   accessor->set_base(left->AsIdentifier()->value());
-  accessor->set_index(value.Pass());
-  return accessor.Pass();
+  accessor->set_index(std::move(value));
+  return std::move(accessor);
 }
 
 scoped_ptr<ParseNode> Parser::DotOperator(scoped_ptr<ParseNode> left,
                                           Token token) {
   if (left->AsIdentifier() == nullptr) {
     *err_ = Err(left.get(), "May only use \".\" for identifiers.",
         "The thing on the left hand side of the dot must be an identifier\n"
         "and not an expression. If you need this, you'll have to assign the\n"
         "value to a temporary first. Sorry.");
     return scoped_ptr<ParseNode>();
   }
 
   scoped_ptr<ParseNode> right = ParseExpression(PRECEDENCE_DOT);
   if (!right || !right->AsIdentifier()) {
     *err_ = Err(token, "Expected identifier for right-hand-side of \".\"",
         "Good: a.cookies\nBad: a.42\nLooks good but still bad: a.cookies()");
     return scoped_ptr<ParseNode>();
   }
 
   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.Pass();
+  return std::move(accessor);
 }
 
 // Does not Consume the start or end token.
 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(start_token);
   bool just_got_comma = false;
   bool first_time = true;
@@ skipping 24 matching lines @@
       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(make_scoped_ptr(new EndNode(cur_token())));
-  return list.Pass();
+  return list;
 }
 
 scoped_ptr<ParseNode> Parser::ParseFile() {
   scoped_ptr<BlockNode> file(new BlockNode);
   for (;;) {
     if (at_end())
       break;
     scoped_ptr<ParseNode> statement = ParseStatement();
     if (!statement)
       break;
-    file->append_statement(statement.Pass());
+    file->append_statement(std::move(statement));
   }
   if (!at_end() && !has_error())
     *err_ = Err(cur_token(), "Unexpected here, should be newline.");
   if (has_error())
     return scoped_ptr<ParseNode>();
 
   // TODO(scottmg): If this is measurably expensive, it could be done only
   // when necessary (when reformatting, or during tests). Comments are
   // separate from the parse tree at this point, so downstream code can remain
   // ignorant of them.
   AssignComments(file.get());
 
-  return file.Pass();
+  return std::move(file);
 }
 
 scoped_ptr<ParseNode> Parser::ParseStatement() {
   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();
+        return stmt;
     }
     if (!has_error()) {
       Token token = at_end() ? tokens_[tokens_.size() - 1] : cur_token();
       *err_ = Err(token, "Expecting assignment or function call.");
     }
     return scoped_ptr<ParseNode>();
   }
 }
 
 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);
   block->set_begin_token(begin_token);
 
   for (;;) {
     if (LookAhead(Token::RIGHT_BRACE)) {
       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());
+    block->append_statement(std::move(statement));
   }
-  return block.Pass();
+  return block;
 }
 
 scoped_ptr<ParseNode> Parser::ParseCondition() {
   scoped_ptr<ConditionNode> condition(new ConditionNode);
   condition->set_if_token(Consume(Token::IF, "Expected 'if'"));
   Consume(Token::LEFT_PAREN, "Expected '(' after 'if'.");
   condition->set_condition(ParseExpression());
   if (IsAssignment(condition->condition()))
     *err_ = Err(condition->condition(), "Assignment not allowed in 'if'.");
   Consume(Token::RIGHT_PAREN, "Expected ')' after condition of 'if'.");
-  condition->set_if_true(ParseBlock().Pass());
+  condition->set_if_true(ParseBlock());
   if (Match(Token::ELSE)) {
     if (LookAhead(Token::LEFT_BRACE)) {
-      condition->set_if_false(ParseBlock().Pass());
+      condition->set_if_false(ParseBlock());
     } else if (LookAhead(Token::IF)) {
-      condition->set_if_false(ParseStatement().Pass());
+      condition->set_if_false(ParseStatement());
     } else {
       *err_ = Err(cur_token(), "Expected '{' or 'if' after 'else'.");
       return scoped_ptr<ParseNode>();
     }
   }
   if (has_error())
     return scoped_ptr<ParseNode>();
-  return condition.Pass();
+  return std::move(condition);
 }
 
 void Parser::TraverseOrder(const ParseNode* root,
                            std::vector<const ParseNode*>* pre,
                            std::vector<const ParseNode*>* post) {
   if (root) {
     pre->push_back(root);
 
     if (const AccessorNode* accessor = root->AsAccessor()) {
       TraverseOrder(accessor->index(), pre, post);
@@ skipping 93 matching lines @@
         break;
       }
     }
 
     // Suffix comments were assigned in reverse, so if there were multiple on
     // the same node, they need to be reversed.
     if ((*i)->comments() && !(*i)->comments()->suffix().empty())
       const_cast<ParseNode*>(*i)->comments_mutable()->ReverseSuffix();
   }
 }