Replace more for loops in GN

tools/gn/builder.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/builder.h"
 
 #include "tools/gn/config.h"
 #include "tools/gn/deps_iterator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/loader.h"
@@ skipping 11 matching lines @@
 // participates in a cycle.
 //
 // If this returns true, the cycle will be in *path. This should point to an
 // empty vector for the first call. During computation, the path will contain
 // the full dependency path to the current node.
 //
 // Return false means no cycle was found.
 bool RecursiveFindCycle(const BuilderRecord* search_in,
                         std::vector<const BuilderRecord*>* path) {
   path->push_back(search_in);
-
-  const BuilderRecord::BuilderRecordSet& unresolved =
-      search_in->unresolved_deps();
-  for (BuilderRecord::BuilderRecordSet::const_iterator i = unresolved.begin();
-       i != unresolved.end(); ++i) {
-    const BuilderRecord* cur = *i;
-
+  for (const auto& cur : search_in->unresolved_deps()) {
     std::vector<const BuilderRecord*>::iterator found =
         std::find(path->begin(), path->end(), cur);
     if (found != path->end()) {
       // This item is already in the set, we found the cycle. Everything before
       // the first definition of cur is irrelevant to the cycle.
       path->erase(path->begin(), found);
       path->push_back(cur);
       return true;
     }
 
@@ skipping 76 matching lines @@
   if (!record)
     return NULL;
   if (!record->item())
     return NULL;
   return record->item()->AsToolchain();
 }
 
 std::vector<const BuilderRecord*> Builder::GetAllRecords() const {
   std::vector<const BuilderRecord*> result;
   result.reserve(records_.size());
-  for (RecordMap::const_iterator i = records_.begin();
-       i != records_.end(); ++i)
-    result.push_back(i->second);
+  for (const auto& record : records_)
+    result.push_back(record.second);
   return result;
 }
 
 std::vector<const Target*> Builder::GetAllResolvedTargets() const {
   std::vector<const Target*> result;
   result.reserve(records_.size());
-  for (RecordMap::const_iterator i = records_.begin();
-       i != records_.end(); ++i) {
-    if (i->second->type() == BuilderRecord::ITEM_TARGET &&
-        i->second->should_generate() && i->second->item())
-      result.push_back(i->second->item()->AsTarget());
+  for (const auto& record : records_) {
+    if (record.second->type() == BuilderRecord::ITEM_TARGET &&
+        record.second->should_generate() && record.second->item())
+      result.push_back(record.second->item()->AsTarget());
   }
   return result;
 }
 
 const BuilderRecord* Builder::GetRecord(const Label& label) const {
   // Forward to the non-const version.
   return const_cast<Builder*>(this)->GetRecord(label);
 }
 
 BuilderRecord* Builder::GetRecord(const Label& label) {
   RecordMap::iterator found = records_.find(label);
   if (found == records_.end())
     return NULL;
   return found->second;
 }
 
 bool Builder::CheckForBadItems(Err* err) const {
   // Look for errors where we find a defined node with an item that refers to
   // an undefined one with no item. There may be other nodes in turn depending
   // on our defined one, but listing those isn't helpful: we want to find the
   // broken link.
   //
   // This finds normal "missing dependency" errors but does not find circular
   // dependencies because in this case all items in the cycle will be GENERATED
   // but none will be resolved. If this happens, we'll check explicitly for
   // that below.
   std::vector<const BuilderRecord*> bad_records;
   std::string depstring;
-  for (RecordMap::const_iterator i = records_.begin();
-       i != records_.end(); ++i) {
-    const BuilderRecord* src = i->second;
+  for (const auto& record_pair : records_) {
+    const BuilderRecord* src = record_pair.second;
     if (!src->should_generate())
       continue;  // Skip ungenerated nodes.
 
     if (!src->resolved()) {
       bad_records.push_back(src);
 
       // Check dependencies.
-      for (BuilderRecord::BuilderRecordSet::const_iterator dest_iter =
-               src->unresolved_deps().begin();
-          dest_iter != src->unresolved_deps().end();
-          ++dest_iter) {
-        const BuilderRecord* dest = *dest_iter;
+      for (const auto& dest : src->unresolved_deps()) {
         if (!dest->item()) {
           depstring += src->label().GetUserVisibleName(true) +
               "\n  needs " + dest->label().GetUserVisibleName(true) + "\n";
         }
       }
     }
   }
 
   if (!depstring.empty()) {
     *err = Err(Location(), "Unresolved dependencies.", depstring);
     return false;
   }
 
   if (!bad_records.empty()) {
     // Our logic above found a bad node but didn't identify the problem. This
     // normally means a circular dependency.
     depstring = CheckForCircularDependencies(bad_records);
     if (depstring.empty()) {
       // Something's very wrong, just dump out the bad nodes.
       depstring = "I have no idea what went wrong, but these are unresolved, "
           "possibly due to an\ninternal error:";
-      for (size_t i = 0; i < bad_records.size(); i++) {
+      for (const auto& bad_record : bad_records) {
         depstring += "\n\"" +
-            bad_records[i]->label().GetUserVisibleName(false) + "\"";
+            bad_record->label().GetUserVisibleName(false) + "\"";
       }
       *err = Err(Location(), "", depstring);
     } else {
       *err = Err(Location(), "Dependency cycle:", depstring);
     }
     return false;
   }
 
   return true;
 }
@@ skipping 95 matching lines @@
         item->GetItemTypeName() + " instead of a " +
         BuilderRecord::GetNameForType(type) + ".");
     return NULL;
   }
   return record;
 }
 
 bool Builder::AddDeps(BuilderRecord* record,
                       const LabelConfigVector& configs,
                       Err* err) {
-  for (size_t i = 0; i < configs.size(); i++) {
+  for (const auto& config : configs) {
     BuilderRecord* dep_record = GetOrCreateRecordOfType(
-        configs[i].label, configs[i].origin, BuilderRecord::ITEM_CONFIG, err);
+        config.label, config.origin, BuilderRecord::ITEM_CONFIG, err);
     if (!dep_record)
       return false;
     record->AddDep(dep_record);
   }
   return true;
 }
 
 bool Builder::AddDeps(BuilderRecord* record,
                       const UniqueVector<LabelConfigPair>& configs,
                       Err* err) {
-  for (size_t i = 0; i < configs.size(); i++) {
+  for (const auto& config : configs) {
     BuilderRecord* dep_record = GetOrCreateRecordOfType(
-        configs[i].label, configs[i].origin, BuilderRecord::ITEM_CONFIG, err);
+        config.label, config.origin, BuilderRecord::ITEM_CONFIG, err);
     if (!dep_record)
       return false;
     record->AddDep(dep_record);
   }
   return true;
 }
 
 bool Builder::AddDeps(BuilderRecord* record,
                       const LabelTargetVector& targets,
                       Err* err) {
-  for (size_t i = 0; i < targets.size(); i++) {
+  for (const auto& target : targets) {
     BuilderRecord* dep_record = GetOrCreateRecordOfType(
-        targets[i].label, targets[i].origin, BuilderRecord::ITEM_TARGET, err);
+        target.label, target.origin, BuilderRecord::ITEM_TARGET, err);
     if (!dep_record)
       return false;
     record->AddDep(dep_record);
   }
   return true;
 }
 
 bool Builder::AddToolchainDep(BuilderRecord* record,
                               const Target* target,
                               Err* err) {
   BuilderRecord* toolchain_record = GetOrCreateRecordOfType(
       target->settings()->toolchain_label(), target->defined_from(),
       BuilderRecord::ITEM_TOOLCHAIN, err);
   if (!toolchain_record)
     return false;
   record->AddDep(toolchain_record);
 
   return true;
 }
 
 void Builder::RecursiveSetShouldGenerate(BuilderRecord* record,
                                          bool force) {
   if (!force && record->should_generate())
     return;  // Already set.
   record->set_should_generate(true);
 
-  const BuilderRecordSet& deps = record->all_deps();
-  for (BuilderRecordSet::const_iterator i = deps.begin();
-       i != deps.end(); i++) {
-    BuilderRecord* cur = *i;
+  for (const auto& cur : record->all_deps()) {
     if (!cur->should_generate()) {
       ScheduleItemLoadIfNecessary(cur);
       RecursiveSetShouldGenerate(cur, false);
     }
   }
 }
 
 void Builder::ScheduleItemLoadIfNecessary(BuilderRecord* record) {
   const ParseNode* origin = record->originally_referenced_from();
   loader_->Load(record->label(),
@@ skipping 21 matching lines @@
   }
 
   record->set_resolved(true);
 
   if (!record->item()->OnResolved(err))
     return false;
   if (!resolved_callback_.is_null())
     resolved_callback_.Run(record);
 
   // Recursively update everybody waiting on this item to be resolved.
-  BuilderRecordSet& waiting_set = record->waiting_on_resolution();
-  for (BuilderRecordSet::iterator i = waiting_set.begin();
-       i != waiting_set.end(); ++i) {
-    BuilderRecord* waiting = *i;
+  for (BuilderRecord* waiting : record->waiting_on_resolution()) {
     DCHECK(waiting->unresolved_deps().find(record) !=
            waiting->unresolved_deps().end());
     waiting->unresolved_deps().erase(record);
 
     if (waiting->can_resolve()) {
       if (!ResolveItem(waiting, err))
         return false;
     }
   }
-  waiting_set.clear();
+  record->waiting_on_resolution().clear();
   return true;
 }
 
 bool Builder::ResolveDeps(LabelTargetVector* deps, Err* err) {
-  for (size_t i = 0; i < deps->size(); i++) {
-    LabelTargetPair& cur = (*deps)[i];
+  for (LabelTargetPair& cur : *deps) {
     DCHECK(!cur.ptr);
 
     BuilderRecord* record = GetResolvedRecordOfType(
         cur.label, cur.origin, BuilderRecord::ITEM_TARGET, err);
     if (!record)
       return false;
     cur.ptr = record->item()->AsTarget();
   }
   return true;
 }
 
 bool Builder::ResolveConfigs(UniqueVector<LabelConfigPair>* configs, Err* err) {
-  for (size_t i = 0; i < configs->size(); i++) {
-    const LabelConfigPair& cur = (*configs)[i];
+  for (const auto& cur : *configs) {
     DCHECK(!cur.ptr);
 
     BuilderRecord* record = GetResolvedRecordOfType(
         cur.label, cur.origin, BuilderRecord::ITEM_CONFIG, err);
     if (!record)
       return false;
     const_cast<LabelConfigPair&>(cur).ptr = record->item()->AsConfig();
   }
   return true;
 }
 
 // "Forward dependent configs" should refer to targets in the deps that should
 // have their configs forwarded.
 bool Builder::ResolveForwardDependentConfigs(Target* target, Err* err) {
   const UniqueVector<LabelTargetPair>& configs =
       target->forward_dependent_configs();
 
   // Assume that the lists are small so that brute-force n^2 is appropriate.
-  for (size_t config_i = 0; config_i < configs.size(); config_i++) {
+  for (const auto& config : configs) {
     for (const auto& dep_pair : target->GetDeps(Target::DEPS_LINKED)) {
-      if (configs[config_i].label == dep_pair.label) {
+      if (config.label == dep_pair.label) {
         DCHECK(dep_pair.ptr);  // Should already be resolved.
         // UniqueVector's contents are constant so uniqueness is preserved, but
         // we want to update this pointer which doesn't change uniqueness
         // (uniqueness in this vector is determined by the label only).
-        const_cast<LabelTargetPair&>(configs[config_i]).ptr = dep_pair.ptr;
+        const_cast<LabelTargetPair&>(config).ptr = dep_pair.ptr;
         break;
       }
     }
-    if (!configs[config_i].ptr) {
+    if (!config.ptr) {
       *err = Err(target->defined_from(),
           "Target in forward_dependent_configs_from was not listed in the deps",
           "This target has a forward_dependent_configs_from entry that was "
           "not present in\nthe deps. A target can only forward things it "
           "depends on. It was forwarding:\n  " +
-          configs[config_i].label.GetUserVisibleName(false));
+          config.label.GetUserVisibleName(false));
       return false;
     }
   }
   return true;
 }
 
 bool Builder::ResolveToolchain(Target* target, Err* err) {
   BuilderRecord* record = GetResolvedRecordOfType(
       target->settings()->toolchain_label(), target->defined_from(),
       BuilderRecord::ITEM_TOOLCHAIN, err);
@@ skipping 20 matching lines @@
   std::string ret;
   for (size_t i = 0; i < cycle.size(); i++) {
     ret += "  " + cycle[i]->label().GetUserVisibleName(false);
     if (i != cycle.size() - 1)
       ret += " ->";
     ret += "\n";
   }
 
   return ret;
 }