Replace more for loops in GN

tools/gn/parse_tree.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/parse_tree.h"
 
 #include <string>
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 41 matching lines @@
 
 Comments* ParseNode::comments_mutable() {
   if (!comments_)
     comments_.reset(new Comments);
   return comments_.get();
 }
 
 void ParseNode::PrintComments(std::ostream& out, int indent) const {
   if (comments_) {
     std::string ind = IndentFor(indent + 1);
-    for (std::vector<Token>::const_iterator i(comments_->before().begin());
-         i != comments_->before().end();
-         ++i) {
-      out << ind << "+BEFORE_COMMENT(\"" << i->value() << "\")\n";
-    }
-    for (std::vector<Token>::const_iterator i(comments_->suffix().begin());
-         i != comments_->suffix().end();
-         ++i) {
-      out << ind << "+SUFFIX_COMMENT(\"" << i->value() << "\")\n";
-    }
-    for (std::vector<Token>::const_iterator i(comments_->after().begin());
-         i != comments_->after().end();
-         ++i) {
-      out << ind << "+AFTER_COMMENT(\"" << i->value() << "\")\n";
-    }
+    for (const auto& token : comments_->before())
+      out << ind << "+BEFORE_COMMENT(\"" << token.value() << "\")\n";
+    for (const auto& token : comments_->suffix())
+      out << ind << "+SUFFIX_COMMENT(\"" << token.value() << "\")\n";
+    for (const auto& token : comments_->after())
+      out << ind << "+AFTER_COMMENT(\"" << token.value() << "\")\n";
   }
 }
 
 // AccessorNode ---------------------------------------------------------------
 
 AccessorNode::AccessorNode() {
 }
 
 AccessorNode::~AccessorNode() {
 }
@@ skipping 187 matching lines @@
 }
 
 Err BlockNode::MakeErrorDescribing(const std::string& msg,
                                    const std::string& help) const {
   return Err(GetRange(), msg, help);
 }
 
 void BlockNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "BLOCK\n";
   PrintComments(out, indent);
-  for (size_t i = 0; i < statements_.size(); i++)
-    statements_[i]->Print(out, indent + 1);
+  for (const auto& statement : statements_)
+    statement->Print(out, indent + 1);
   if (end_ && end_->comments())
     end_->Print(out, indent + 1);
 }
 
 Value BlockNode::ExecuteBlockInScope(Scope* our_scope, Err* err) const {
   for (size_t i = 0; i < statements_.size() && !err->has_error(); i++) {
     // Check for trying to execute things with no side effects in a block.
     const ParseNode* cur = statements_[i];
     if (cur->AsList() || cur->AsLiteral() || cur->AsUnaryOp() ||
         cur->AsIdentifier()) {
@@ skipping 160 matching lines @@
 
 const ListNode* ListNode::AsList() const {
   return this;
 }
 
 Value ListNode::Execute(Scope* scope, Err* err) const {
   Value result_value(this, Value::LIST);
   std::vector<Value>& results = result_value.list_value();
   results.reserve(contents_.size());
 
-  for (size_t i = 0; i < contents_.size(); i++) {
-    const ParseNode* cur = contents_[i];
+  for (const auto& cur : contents_) {
     if (cur->AsBlockComment())
       continue;
     results.push_back(cur->Execute(scope, err));
     if (err->has_error())
       return Value();
     if (results.back().type() == Value::NONE) {
       *err = cur->MakeErrorDescribing(
           "This does not evaluate to a value.",
           "I can't do something with nothing.");
       return Value();
     }
   }
   return result_value;
 }
 
 LocationRange ListNode::GetRange() const {
   return LocationRange(begin_token_.location(),
                        end_->value().location());
 }
 
 Err ListNode::MakeErrorDescribing(const std::string& msg,
                                   const std::string& help) const {
   return Err(begin_token_, msg, help);
 }
 
 void ListNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "LIST\n";
   PrintComments(out, indent);
-  for (size_t i = 0; i < contents_.size(); i++)
-    contents_[i]->Print(out, indent + 1);
+  for (const auto& cur : contents_)
+    cur->Print(out, indent + 1);
   if (end_ && end_->comments())
     end_->Print(out, indent + 1);
 }
 
 // LiteralNode -----------------------------------------------------------------
 
 LiteralNode::LiteralNode() {
 }
 
 LiteralNode::LiteralNode(const Token& token) : value_(token) {
@@ skipping 132 matching lines @@
 
 Err EndNode::MakeErrorDescribing(const std::string& msg,
                                         const std::string& help) const {
   return Err(value_, msg, help);
 }
 
 void EndNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "END(" << value_.value() << ")\n";
   PrintComments(out, indent);
 }