Replace more for loops in GN

tools/gn/ninja_binary_target_writer.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/ninja_binary_target_writer.h"
 
 #include <set>
 #include <sstream>
 
 #include "base/strings/string_util.h"
@@ skipping 115 matching lines @@
   WRITE_FLAGS(cflags_objc, SUBSTITUTION_CFLAGS_OBJC)
   WRITE_FLAGS(cflags_objcc, SUBSTITUTION_CFLAGS_OBJCC)
 
 #undef WRITE_FLAGS
 
   WriteSharedVars(subst);
 }
 
 void NinjaBinaryTargetWriter::WriteSources(
     std::vector<OutputFile>* object_files) {
-  const Target::FileList& sources = target_->sources();
-  object_files->reserve(sources.size());
+  object_files->reserve(target_->sources().size());
 
   OutputFile input_dep =
       WriteInputDepsStampAndGetDep(std::vector<const Target*>());
 
   std::string rule_prefix = GetNinjaRulePrefixForToolchain(settings_);
 
   std::vector<OutputFile> tool_outputs;  // Prevent reallocation in loop.
-  for (size_t i = 0; i < sources.size(); i++) {
+  for (const auto& source : target_->sources()) {
     Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
-    if (!GetOutputFilesForSource(target_, sources[i],
+    if (!GetOutputFilesForSource(target_, source,
                                  &tool_type, &tool_outputs))
       continue;  // No output for this source.
 
     if (tool_type != Toolchain::TYPE_NONE) {
       out_ << "build";
       path_output_.WriteFiles(out_, tool_outputs);
       out_ << ": " << rule_prefix << Toolchain::ToolTypeToName(tool_type);
       out_ << " ";
-      path_output_.WriteFile(out_, sources[i]);
+      path_output_.WriteFile(out_, source);
       if (!input_dep.value().empty()) {
         // Write out the input dependencies as an order-only dependency. This
         // will cause Ninja to make sure the inputs are up-to-date before
         // compiling this source, but changes in the inputs deps won't cause
         // the file to be recompiled.
         //
         // This is important to prevent changes in unrelated actions that
         // are upstream of this target from causing everything to be recompiled.
         //
         // Why can we get away with this rather than using implicit deps ("|",
@@ skipping 38 matching lines @@
        << GetNinjaRulePrefixForToolchain(settings_)
        << Toolchain::ToolTypeToName(
               target_->toolchain()->GetToolTypeForTargetFinalOutput(target_));
 
   UniqueVector<OutputFile> extra_object_files;
   UniqueVector<const Target*> linkable_deps;
   UniqueVector<const Target*> non_linkable_deps;
   GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);
 
   // Object files.
-  for (size_t i = 0; i < object_files.size(); i++) {
+  for (const auto& obj : object_files) {
     out_ << " ";
-    path_output_.WriteFile(out_, object_files[i]);
+    path_output_.WriteFile(out_, obj);
   }
-  for (size_t i = 0; i < extra_object_files.size(); i++) {
+  for (const auto& obj : extra_object_files) {
     out_ << " ";
-    path_output_.WriteFile(out_, extra_object_files[i]);
+    path_output_.WriteFile(out_, obj);
   }
 
   std::vector<OutputFile> implicit_deps;
   std::vector<OutputFile> solibs;
 
-  for (size_t i = 0; i < linkable_deps.size(); i++) {
-    const Target* cur = linkable_deps[i];
-
+  for (const Target* cur : linkable_deps) {
     // All linkable deps should have a link output file.
     DCHECK(!cur->link_output_file().value().empty())
         << "No link output file for "
         << target_->label().GetUserVisibleName(false);
 
     if (cur->dependency_output_file().value() !=
         cur->link_output_file().value()) {
       // This is a shared library with separate link and deps files. Save for
       // later.
       implicit_deps.push_back(cur->dependency_output_file());
@@ skipping 118 matching lines @@
   UniqueVector<const Target*> linkable_deps;
   UniqueVector<const Target*> non_linkable_deps;
   GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);
 
   // The classifier should never put extra object files in a source set:
   // any source sets that we depend on should appear in our non-linkable
   // deps instead.
   DCHECK(extra_object_files.empty());
 
   std::vector<OutputFile> order_only_deps;
-  for (size_t i = 0; i < non_linkable_deps.size(); i++)
-    order_only_deps.push_back(non_linkable_deps[i]->dependency_output_file());
+  for (const auto& dep : non_linkable_deps)
+    order_only_deps.push_back(dep->dependency_output_file());
 
   WriteStampForTarget(object_files, order_only_deps);
 }
 
 void NinjaBinaryTargetWriter::GetDeps(
     UniqueVector<OutputFile>* extra_object_files,
     UniqueVector<const Target*>* linkable_deps,
     UniqueVector<const Target*>* non_linkable_deps) const {
   // Normal public/private deps.
   for (const auto& pair : target_->GetDeps(Target::DEPS_LINKED)) {
@@ skipping 31 matching lines @@
     // Source sets have their object files linked into final targets
     // (shared libraries, executables, and complete static
     // libraries). Intermediate static libraries and other source sets
     // just forward the dependency, otherwise the files in the source
     // set can easily get linked more than once which will cause
     // multiple definition errors.
     if (can_link_libs) {
       // Linking in a source set to an executable, shared library, or
       // complete static library, so copy its object files.
       std::vector<OutputFile> tool_outputs;  // Prevent allocation in loop.
-      for (size_t i = 0; i < dep->sources().size(); i++) {
+      for (const auto& source : dep->sources()) {
         Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
-        if (GetOutputFilesForSource(dep, dep->sources()[i], &tool_type,
-                                    &tool_outputs)) {
+        if (GetOutputFilesForSource(dep, source, &tool_type, &tool_outputs)) {
           // Only link the first output if there are more than one.
           extra_object_files->push_back(tool_outputs[0]);
         }
       }
     }
   } else if (can_link_libs && dep->IsLinkable()) {
     linkable_deps->push_back(dep);
   } else {
     non_linkable_deps->push_back(dep);
   }
@@ skipping 37 matching lines @@
     return false;  // No tool for this file (it's a header file or something).
   const Tool* tool = target->toolchain()->GetTool(*computed_tool_type);
   if (!tool)
     return false;  // Tool does not apply for this toolchain.file.
 
   // Figure out what output(s) this compiler produces.
   SubstitutionWriter::ApplyListToCompilerAsOutputFile(
       target, source, tool->outputs(), outputs);
   return !outputs->empty();
 }