Replace more for loops in GN

tools/gn/scope.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/scope.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/template.h"
@@ skipping 39 matching lines @@
 }
 
 Scope::~Scope() {
   STLDeleteContainerPairSecondPointers(target_defaults_.begin(),
                                        target_defaults_.end());
 }
 
 const Value* Scope::GetValue(const base::StringPiece& ident,
                              bool counts_as_used) {
   // First check for programatically-provided values.
-  for (ProviderSet::const_iterator i = programmatic_providers_.begin();
-       i != programmatic_providers_.end(); ++i) {
-    const Value* v = (*i)->GetProgrammaticValue(ident);
+  for (const auto& provider : programmatic_providers_) {
+    const Value* v = provider->GetProgrammaticValue(ident);
     if (v)
       return v;
   }
 
   RecordMap::iterator found = values_.find(ident);
   if (found != values_.end()) {
     if (counts_as_used)
       found->second.used = true;
     return &found->second.value;
   }
@@ skipping 62 matching lines @@
   if (found != values_.end())
     values_.erase(found);
 }
 
 void Scope::RemovePrivateIdentifiers() {
   // Do it in two phases to avoid mutating while iterating. Our hash map is
   // currently backed by several different vendor-specific implementations and
   // I'm not sure if all of them support mutating while iterating. Since this
   // is not perf-critical, do the safe thing.
   std::vector<base::StringPiece> to_remove;
-  for (RecordMap::const_iterator i = values_.begin(); i != values_.end(); ++i) {
-    if (IsPrivateVar(i->first))
-      to_remove.push_back(i->first);
+  for (const auto& cur : values_) {
+    if (IsPrivateVar(cur.first))
+      to_remove.push_back(cur.first);
   }
 
-  for (size_t i = 0; i < to_remove.size(); i++)
-    values_.erase(to_remove[i]);
+  for (const auto& cur : to_remove)
+    values_.erase(cur);
 }
 
 bool Scope::AddTemplate(const std::string& name, const Template* templ) {
   if (GetTemplate(name))
     return false;
   templates_[name] = templ;
   return true;
 }
 
 const Template* Scope::GetTemplate(const std::string& name) const {
@@ skipping 27 matching lines @@
   RecordMap::const_iterator found = values_.find(ident);
   if (found != values_.end()) {
     if (!found->second.used) {
       return true;
     }
   }
   return false;
 }
 
 bool Scope::CheckForUnusedVars(Err* err) const {
-  for (RecordMap::const_iterator i = values_.begin();
-       i != values_.end(); ++i) {
-    if (!i->second.used) {
-      std::string help = "You set the variable \"" + i->first.as_string() +
+  for (const auto& pair : values_) {
+    if (!pair.second.used) {
+      std::string help = "You set the variable \"" + pair.first.as_string() +
           "\" here and it was unused before it went\nout of scope.";
 
-      const BinaryOpNode* binary = i->second.value.origin()->AsBinaryOp();
+      const BinaryOpNode* binary = pair.second.value.origin()->AsBinaryOp();
       if (binary && binary->op().type() == Token::EQUAL) {
         // Make a nicer error message for normal var sets.
         *err = Err(binary->left()->GetRange(), "Assignment had no effect.",
                    help);
       } else {
         // This will happen for internally-generated variables.
-        *err = Err(i->second.value.origin(), "Assignment had no effect.", help);
+        *err = Err(pair.second.value.origin(), "Assignment had no effect.",
+                   help);
       }
       return false;
     }
   }
   return true;
 }
 
 void Scope::GetCurrentScopeValues(KeyValueMap* output) const {
-  for (RecordMap::const_iterator i = values_.begin(); i != values_.end(); ++i)
-    (*output)[i->first] = i->second.value;
+  for (const auto& pair : values_)
+    (*output)[pair.first] = pair.second.value;
 }
 
 bool Scope::NonRecursiveMergeTo(Scope* dest,
                                 const MergeOptions& options,
                                 const ParseNode* node_for_err,
                                 const char* desc_for_err,
                                 Err* err) const {
   // Values.
-  for (RecordMap::const_iterator i = values_.begin(); i != values_.end(); ++i) {
-    if (options.skip_private_vars && IsPrivateVar(i->first))
+  for (const auto& pair : values_) {
+    if (options.skip_private_vars && IsPrivateVar(pair.first))
       continue;  // Skip this private var.
 
-    const Value& new_value = i->second.value;
+    const Value& new_value = pair.second.value;
     if (!options.clobber_existing) {
-      const Value* existing_value = dest->GetValue(i->first);
+      const Value* existing_value = dest->GetValue(pair.first);
       if (existing_value && new_value != *existing_value) {
         // Value present in both the source and the dest.
         std::string desc_string(desc_for_err);
         *err = Err(node_for_err, "Value collision.",
-            "This " + desc_string + " contains \"" + i->first.as_string() +
+            "This " + desc_string + " contains \"" + pair.first.as_string() +
             "\"");
-        err->AppendSubErr(Err(i->second.value, "defined here.",
+        err->AppendSubErr(Err(pair.second.value, "defined here.",
             "Which would clobber the one in your current scope"));
         err->AppendSubErr(Err(*existing_value, "defined here.",
             "Executing " + desc_string + " should not conflict with anything "
             "in the current\nscope unless the values are identical."));
         return false;
       }
     }
-    dest->values_[i->first] = i->second;
+    dest->values_[pair.first] = pair.second;
 
     if (options.mark_used)
-      dest->MarkUsed(i->first);
+      dest->MarkUsed(pair.first);
   }
 
   // Target defaults are owning pointers.
-  for (NamedScopeMap::const_iterator i = target_defaults_.begin();
-       i != target_defaults_.end(); ++i) {
+  for (const auto& pair : target_defaults_) {
     if (!options.clobber_existing) {
-      if (dest->GetTargetDefaults(i->first)) {
+      if (dest->GetTargetDefaults(pair.first)) {
         // TODO(brettw) it would be nice to know the origin of a
         // set_target_defaults so we can give locations for the colliding target
         // defaults.
         std::string desc_string(desc_for_err);
         *err = Err(node_for_err, "Target defaults collision.",
             "This " + desc_string + " contains target defaults for\n"
-            "\"" + i->first + "\" which would clobber one for the\n"
+            "\"" + pair.first + "\" which would clobber one for the\n"
             "same target type in your current scope. It's unfortunate that I'm "
             "too stupid\nto tell you the location of where the target defaults "
             "were set. Usually\nthis happens in the BUILDCONFIG.gn file.");
         return false;
       }
     }
 
     // Be careful to delete any pointer we're about to clobber.
-    Scope** dest_scope = &dest->target_defaults_[i->first];
+    Scope** dest_scope = &dest->target_defaults_[pair.first];
     if (*dest_scope)
       delete *dest_scope;
     *dest_scope = new Scope(settings_);
-    i->second->NonRecursiveMergeTo(*dest_scope, options, node_for_err,
-                                   "<SHOULDN'T HAPPEN>", err);
+    pair.second->NonRecursiveMergeTo(*dest_scope, options, node_for_err,
+                                     "<SHOULDN'T HAPPEN>", err);
   }
 
   // Sources assignment filter.
   if (sources_assignment_filter_) {
     if (!options.clobber_existing) {
       if (dest->GetSourcesAssignmentFilter()) {
         // Sources assignment filter present in both the source and the dest.
         std::string desc_string(desc_for_err);
         *err = Err(node_for_err, "Assignment filter collision.",
             "The " + desc_string + " contains a sources_assignment_filter "
             "which\nwould clobber the one in your current scope.");
         return false;
       }
     }
     dest->sources_assignment_filter_.reset(
         new PatternList(*sources_assignment_filter_));
   }
 
   // Templates.
-  for (TemplateMap::const_iterator i = templates_.begin();
-       i != templates_.end(); ++i) {
-    if (options.skip_private_vars && IsPrivateVar(i->first))
+  for (const auto& pair : templates_) {
+    if (options.skip_private_vars && IsPrivateVar(pair.first))
       continue;  // Skip this private template.
 
     if (!options.clobber_existing) {
-      const Template* existing_template = dest->GetTemplate(i->first);
+      const Template* existing_template = dest->GetTemplate(pair.first);
       // Since templates are refcounted, we can check if it's the same one by
       // comparing pointers.
-      if (existing_template && i->second.get() != existing_template) {
+      if (existing_template && pair.second.get() != existing_template) {
         // Rule present in both the source and the dest, and they're not the
         // same one.
         std::string desc_string(desc_for_err);
         *err = Err(node_for_err, "Template collision.",
             "This " + desc_string + " contains a template \"" +
-            i->first + "\"");
-        err->AppendSubErr(Err(i->second->GetDefinitionRange(), "defined here.",
+            pair.first + "\"");
+        err->AppendSubErr(Err(pair.second->GetDefinitionRange(),
+            "defined here.",
             "Which would clobber the one in your current scope"));
         err->AppendSubErr(Err(existing_template->GetDefinitionRange(),
             "defined here.",
             "Executing " + desc_string + " should not conflict with anything "
             "in the current\nscope."));
         return false;
       }
     }
 
     // Be careful to delete any pointer we're about to clobber.
-    dest->templates_[i->first] = i->second;
+    dest->templates_[pair.first] = pair.second;
   }
 
   return true;
 }
 
 scoped_ptr<Scope> Scope::MakeClosure() const {
   scoped_ptr<Scope> result;
   if (const_containing_) {
     // We reached the top of the mutable scope stack. The result scope just
     // references the const scope (which will never change).
@@ skipping 123 matching lines @@
 }
 
 void Scope::AddProvider(ProgrammaticProvider* p) {
   programmatic_providers_.insert(p);
 }
 
 void Scope::RemoveProvider(ProgrammaticProvider* p) {
   DCHECK(programmatic_providers_.find(p) != programmatic_providers_.end());
   programmatic_providers_.erase(p);
 }