Replace more for loops in GN

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 64 matching lines @@
   {&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
   {&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()) {
+  for (const auto& token : tokens) {
+    switch(token.type()) {
       case Token::LINE_COMMENT:
-        line_comment_tokens_.push_back(*i);
+        line_comment_tokens_.push_back(token);
         break;
       case Token::SUFFIX_COMMENT:
-        suffix_comment_tokens_.push_back(*i);
+        suffix_comment_tokens_.push_back(token);
         break;
       default:
         // Note that BLOCK_COMMENTs (top-level standalone comments) are passed
         // through the real parser.
-        tokens_.push_back(*i);
+        tokens_.push_back(token);
         break;
     }
   }
 }
 
 Parser::~Parser() {
 }
 
 // static
 scoped_ptr<ParseNode> Parser::Parse(const std::vector<Token>& tokens,
@@ skipping 405 matching lines @@
   if (root) {
     pre->push_back(root);
 
     if (const AccessorNode* accessor = root->AsAccessor()) {
       TraverseOrder(accessor->index(), pre, post);
       TraverseOrder(accessor->member(), pre, post);
     } 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);
-      }
+      for (const auto& statement : block->statements())
+        TraverseOrder(statement, 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);
-      }
+      for (const auto& node : list->contents())
+        TraverseOrder(node, 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
   // can determine what's before and after comments.
   std::vector<const ParseNode*> pre;
   std::vector<const ParseNode*> post;
   TraverseOrder(file, &pre, &post);
 
   // Assign line comments to syntax immediately following.
   int cur_comment = 0;
-  for (std::vector<const ParseNode*>::const_iterator i = pre.begin();
-       i != pre.end();
-       ++i) {
-    const Location& start = (*i)->GetRange().begin();
+  for (const auto& node : pre) {
+    const Location& start = node->GetRange().begin();
     while (cur_comment < static_cast<int>(line_comment_tokens_.size())) {
       if (start.byte() >= line_comment_tokens_[cur_comment].location().byte()) {
-        const_cast<ParseNode*>(*i)->comments_mutable()->append_before(
+        const_cast<ParseNode*>(node)->comments_mutable()->append_before(
             line_comment_tokens_[cur_comment]);
         ++cur_comment;
       } else {
         break;
       }
     }
   }
 
   // Remaining line comments go at end of file.
   for (; cur_comment < static_cast<int>(line_comment_tokens_.size());
@@ skipping 32 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();
   }
 }