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

tools/gn/parser.cc

Index: tools/gn/parser.cc
diff --git a/tools/gn/parser.cc b/tools/gn/parser.cc
index b2e22fb09f63a2f383fd7ee2bcf73896ea570fc2..79966b8ac59c4ce096b7124899df6d01046d4343 100644
--- a/tools/gn/parser.cc
+++ b/tools/gn/parser.cc
@@ -4,6 +4,8 @@
 
 #include "tools/gn/parser.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
@@ -215,7 +217,7 @@ scoped_ptr<ParseNode> Parser::ParseExpression(const std::vector<Token>& tokens,
     *err = Err(p.cur_token(), "Trailing garbage");
     return nullptr;
   }
-  return expr.Pass();
+  return expr;
 }
 
 // static
@@ -328,7 +330,7 @@ scoped_ptr<ParseNode> Parser::ParseExpression(int precedence) {
 
   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) {
@@ -340,12 +342,12 @@ scoped_ptr<ParseNode> Parser::ParseExpression(int precedence) {
                       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) {
@@ -353,13 +355,13 @@ scoped_ptr<ParseNode> Parser::Literal(Token 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) {
@@ -367,7 +369,7 @@ scoped_ptr<ParseNode> Parser::Group(Token token) {
   if (has_error())
     return scoped_ptr<ParseNode>();
   Consume(Token::RIGHT_PAREN, "Expected ')'");
-  return expr.Pass();
+  return expr;
 }
 
 scoped_ptr<ParseNode> Parser::Not(Token token) {
@@ -381,15 +383,15 @@ scoped_ptr<ParseNode> Parser::Not(Token token) {
   }
   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,
@@ -405,9 +407,9 @@ scoped_ptr<ParseNode> Parser::BinaryOperator(scoped_ptr<ParseNode> left,
   }
   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,
@@ -439,14 +441,14 @@ scoped_ptr<ParseNode> Parser::IdentifierOrCall(scoped_ptr<ParseNode> left,
 
   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,
@@ -463,9 +465,9 @@ scoped_ptr<ParseNode> Parser::Assignment(scoped_ptr<ParseNode> left,
   }
   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,
@@ -483,8 +485,8 @@ scoped_ptr<ParseNode> Parser::Subscript(scoped_ptr<ParseNode> left,
   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,
@@ -508,7 +510,7 @@ scoped_ptr<ParseNode> Parser::DotOperator(scoped_ptr<ParseNode> left,
   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.
@@ -553,7 +555,7 @@ scoped_ptr<ListNode> Parser::ParseList(Token start_token,
     return scoped_ptr<ListNode>();
   }
   list->set_end(make_scoped_ptr(new EndNode(cur_token())));
-  return list.Pass();
+  return list;
 }
 
 scoped_ptr<ParseNode> Parser::ParseFile() {
@@ -564,7 +566,7 @@ scoped_ptr<ParseNode> Parser::ParseFile() {
     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.");
@@ -577,7 +579,7 @@ scoped_ptr<ParseNode> Parser::ParseFile() {
   // ignorant of them.
   AssignComments(file.get());
 
-  return file.Pass();
+  return std::move(file);
 }
 
 scoped_ptr<ParseNode> Parser::ParseStatement() {
@@ -591,7 +593,7 @@ scoped_ptr<ParseNode> Parser::ParseStatement() {
     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();
@@ -618,9 +620,9 @@ scoped_ptr<BlockNode> Parser::ParseBlock() {
     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() {
@@ -631,12 +633,12 @@ scoped_ptr<ParseNode> Parser::ParseCondition() {
   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>();
@@ -644,7 +646,7 @@ scoped_ptr<ParseNode> Parser::ParseCondition() {
   }
   if (has_error())
     return scoped_ptr<ParseNode>();
-  return condition.Pass();
+  return std::move(condition);
 }
 
 void Parser::TraverseOrder(const ParseNode* root,