Convert GN's deps iterator to work with range-based for loops.

tools/gn/target.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/target.h"
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 12 matching lines @@
   const UniqueVector<LabelConfigPair>& pub = from_target->public_configs();
   dest->Append(pub.begin(), pub.end());
 }
 
 // Like MergePublicConfigsFrom above except does the "all dependent" ones. This
 // additionally adds all configs to the all_dependent_configs_ of the dest
 // target given in *all_dest.
 void MergeAllDependentConfigsFrom(const Target* from_target,
                                   UniqueVector<LabelConfigPair>* dest,
                                   UniqueVector<LabelConfigPair>* all_dest) {
-  const UniqueVector<LabelConfigPair>& all =
-      from_target->all_dependent_configs();
-  for (size_t i = 0; i < all.size(); i++) {
-    all_dest->push_back(all[i]);
-    dest->push_back(all[i]);
+  for (const auto& pair : from_target->all_dependent_configs()) {
+    all_dest->push_back(pair);
+    dest->push_back(pair);
   }
 }
 
 Err MakeTestOnlyError(const Target* from, const Target* to) {
   return Err(from->defined_from(), "Test-only dependency not allowed.",
       from->label().GetUserVisibleName(false) + "\n"
       "which is NOT marked testonly can't depend on\n" +
       to->label().GetUserVisibleName(false) + "\n"
       "which is marked testonly. Only targets with \"testonly = true\"\n"
       "can depend on other test-only targets.\n"
@@ skipping 99 matching lines @@
 
 bool Target::IsLinkable() const {
   return output_type_ == STATIC_LIBRARY || output_type_ == SHARED_LIBRARY;
 }
 
 bool Target::IsFinal() const {
   return output_type_ == EXECUTABLE || output_type_ == SHARED_LIBRARY ||
          (output_type_ == STATIC_LIBRARY && complete_static_lib_);
 }
 
+DepsIteratorRange Target::GetDeps(DepsIterationType type) const {
+  if (type == DEPS_LINKED) {
+    return DepsIteratorRange(DepsIterator(
+        &public_deps_, &private_deps_, nullptr));
+  }
+  // All deps.
+  return DepsIteratorRange(DepsIterator(
+      &public_deps_, &private_deps_, &data_deps_));
+}
+
 std::string Target::GetComputedOutputName(bool include_prefix) const {
   DCHECK(toolchain_)
       << "Toolchain must be specified before getting the computed output name.";
 
   const std::string& name = output_name_.empty() ? label().name()
                                                  : output_name_;
 
   std::string result;
   if (include_prefix) {
     const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
@@ skipping 29 matching lines @@
             GetStringForOutputType(output_type_),
             label().GetToolchainLabel().GetUserVisibleName(false).c_str(),
             Toolchain::ToolTypeToName(
                 toolchain->GetToolTypeForTargetFinalOutput(this)).c_str()));
   }
   return false;
 }
 
 void Target::PullDependentTargetInfo() {
   // Gather info from our dependents we need.
-  for (DepsIterator iter(this, DepsIterator::LINKED_ONLY); !iter.done();
-       iter.Advance()) {
-    const Target* dep = iter.target();
+  for (const auto& pair : GetDeps(DEPS_LINKED)) {
+    const Target* dep = pair.ptr;
     MergeAllDependentConfigsFrom(dep, &configs_, &all_dependent_configs_);
     MergePublicConfigsFrom(dep, &configs_);
 
     // Direct dependent libraries.
     if (dep->output_type() == STATIC_LIBRARY ||
         dep->output_type() == SHARED_LIBRARY ||
         dep->output_type() == SOURCE_SET)
       inherited_libraries_.push_back(dep);
 
     // Inherited libraries and flags are inherited across static library
     // boundaries.
     if (!dep->IsFinal()) {
       inherited_libraries_.Append(dep->inherited_libraries().begin(),
                                   dep->inherited_libraries().end());
 
       // Inherited library settings.
       all_lib_dirs_.append(dep->all_lib_dirs());
       all_libs_.append(dep->all_libs());
     }
   }
 }
 
 void Target::PullForwardedDependentConfigs() {
   // Pull public configs from each of our dependency's public deps.
-  for (size_t dep = 0; dep < public_deps_.size(); dep++)
-    PullForwardedDependentConfigsFrom(public_deps_[dep].ptr);
+  for (const auto& dep : public_deps_)
+    PullForwardedDependentConfigsFrom(dep.ptr);
 
   // Forward public configs if explicitly requested.
-  for (size_t dep = 0; dep < forward_dependent_configs_.size(); dep++) {
-    const Target* from_target = forward_dependent_configs_[dep].ptr;
+  for (const auto& dep : forward_dependent_configs_) {
+    const Target* from_target = dep.ptr;
 
     // The forward_dependent_configs_ must be in the deps (public or private)
     // already, so we don't need to bother copying to our configs, only
     // forwarding.
     DCHECK(std::find_if(private_deps_.begin(), private_deps_.end(),
                         LabelPtrPtrEquals<Target>(from_target)) !=
                private_deps_.end() ||
            std::find_if(public_deps_.begin(), public_deps_.end(),
                         LabelPtrPtrEquals<Target>(from_target)) !=
                public_deps_.end());
 
     PullForwardedDependentConfigsFrom(from_target);
   }
 }
 
 void Target::PullForwardedDependentConfigsFrom(const Target* from) {
   public_configs_.Append(from->public_configs().begin(),
                          from->public_configs().end());
 }
 
 void Target::PullRecursiveHardDeps() {
-  for (DepsIterator iter(this, DepsIterator::LINKED_ONLY); !iter.done();
-       iter.Advance()) {
-    if (iter.target()->hard_dep())
-      recursive_hard_deps_.insert(iter.target());
+  for (const auto& pair : GetDeps(DEPS_LINKED)) {
+    if (pair.ptr->hard_dep())
+      recursive_hard_deps_.insert(pair.ptr);
 
     // Android STL doesn't like insert(begin, end) so do it manually.
     // TODO(brettw) this can be changed to
     // insert(iter.target()->begin(), iter.target()->end())
     // when Android uses a better STL.
     for (std::set<const Target*>::const_iterator cur =

[scottmg, 2014/09/27 00:40:07]

for (const auto& cur : pair.ptr->recursive_hard_deps()) ?

[brettw, 2014/09/27 22:21:34]

I'm going to do another pass for the rest. I had to stop somewhere :)

-             iter.target()->recursive_hard_deps().begin();
-         cur != iter.target()->recursive_hard_deps().end(); ++cur)
+             pair.ptr->recursive_hard_deps().begin();
+         cur != pair.ptr->recursive_hard_deps().end(); ++cur)
       recursive_hard_deps_.insert(*cur);
   }
 }
 
 void Target::FillOutputFiles() {
   const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
   switch (output_type_) {
     case GROUP:
     case SOURCE_SET:
     case COPY_FILES:
@@ skipping 44 matching lines @@
         }
       }
       break;
     case UNKNOWN:
     default:
       NOTREACHED();
   }
 }
 
 bool Target::CheckVisibility(Err* err) const {
-  for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
-    if (!Visibility::CheckItemVisibility(this, iter.target(), err))
+  for (const auto& pair : GetDeps(DEPS_ALL)) {
+    if (!Visibility::CheckItemVisibility(this, pair.ptr, err))
       return false;
   }
   return true;
 }
 
 bool Target::CheckTestonly(Err* err) const {
   // If the current target is marked testonly, it can include both testonly
   // and non-testonly targets, so there's nothing to check.
   if (testonly())
     return true;
 
   // Verify no deps have "testonly" set.
-  for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
-    if (iter.target()->testonly()) {
-      *err = MakeTestOnlyError(this, iter.target());
+  for (const auto& pair : GetDeps(DEPS_ALL)) {
+    if (pair.ptr->testonly()) {
+      *err = MakeTestOnlyError(this, pair.ptr);
       return false;
     }
   }
 
   return true;
 }
 
 bool Target::CheckNoNestedStaticLibs(Err* err) const {
   // If the current target is not a complete static library, it can depend on
   // static library targets with no problem.
   if (!(output_type() == Target::STATIC_LIBRARY && complete_static_lib()))
     return true;
 
   // Verify no deps are static libraries.
-  for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
-    if (iter.target()->output_type() == Target::STATIC_LIBRARY) {
-      *err = MakeStaticLibDepsError(this, iter.target());
+  for (const auto& pair : GetDeps(DEPS_ALL)) {
+    if (pair.ptr->output_type() == Target::STATIC_LIBRARY) {
+      *err = MakeStaticLibDepsError(this, pair.ptr);
       return false;
     }
   }
 
   // Verify no inherited libraries are static libraries.
-  for (size_t i = 0; i < inherited_libraries().size(); ++i) {
-    if (inherited_libraries()[i]->output_type() == Target::STATIC_LIBRARY) {
-      *err = MakeStaticLibDepsError(this, inherited_libraries()[i]);
+  for (const auto& lib : inherited_libraries()) {
+    if (lib->output_type() == Target::STATIC_LIBRARY) {
+      *err = MakeStaticLibDepsError(this, lib);
       return false;
     }
   }
   return true;
 }