Replace more for loops in GN

tools/gn/substitution_writer.cc

 // Copyright 2014 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/substitution_writer.h"
 
 #include "tools/gn/build_settings.h"
 #include "tools/gn/escape.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/output_file.h"
@@ skipping 133 matching lines @@
     const EscapeOptions& escape_options,
     std::ostream& out) {
   // The result needs to be quoted as if it was one string, but the $ for
   // the inserted Ninja variables can't be escaped. So write to a buffer with
   // no quoting, and then quote the whole thing if necessary.
   EscapeOptions no_quoting(escape_options);
   no_quoting.inhibit_quoting = true;
 
   bool needs_quotes = false;
   std::string result;
-  for (size_t i = 0; i < pattern.ranges().size(); i++) {
-    const SubstitutionPattern::Subrange range = pattern.ranges()[i];
+  for (const auto& range : pattern.ranges()) {
     if (range.type == SUBSTITUTION_LITERAL) {
       result.append(EscapeString(range.literal, no_quoting, &needs_quotes));
     } else {
       result.append("${");
       result.append(kSubstitutionNinjaNames[range.type]);
       result.append("}");
     }
   }
 
   if (needs_quotes && !escape_options.inhibit_quoting)
     out << "\"" << result << "\"";
   else
     out << result;
 }
 
 // static
 void SubstitutionWriter::GetListAsSourceFiles(
     const SubstitutionList& list,
     std::vector<SourceFile>* output) {
-  for (size_t i = 0; i < list.list().size(); i++) {
-    const SubstitutionPattern& pattern = list.list()[i];
+  for (const auto& pattern : list.list()) {
     CHECK(pattern.ranges().size() == 1 &&
           pattern.ranges()[0].type == SUBSTITUTION_LITERAL)
         << "The substitution patterm \""
         << pattern.AsString()
         << "\" was expected to be a literal with no {{substitutions}}.";
     const std::string& literal = pattern.ranges()[0].literal;
     CHECK(literal.size() >= 1 && literal[0] == '/')
         << "The result of the pattern \""
         << pattern.AsString()
         << "\" was not an absolute path.";
     output->push_back(SourceFile(literal));
   }
 }
 
 // static
 void SubstitutionWriter::GetListAsOutputFiles(
     const Settings* settings,
     const SubstitutionList& list,
     std::vector<OutputFile>* output) {
   std::vector<SourceFile> output_as_sources;
   GetListAsSourceFiles(list, &output_as_sources);
-  for (size_t i = 0; i < output_as_sources.size(); i++) {
-    output->push_back(OutputFile(settings->build_settings(),
-                                 output_as_sources[i]));
-  }
+  for (const auto& file : output_as_sources)
+    output->push_back(OutputFile(settings->build_settings(), file));
 }
 
 // static
 SourceFile SubstitutionWriter::ApplyPatternToSource(
       const Settings* settings,
       const SubstitutionPattern& pattern,
       const SourceFile& source) {
   std::string result_value = ApplyPatternToSourceAsString(
       settings, pattern, source);
   CHECK(!result_value.empty() && result_value[0] == '/')
       << "The result of the pattern \""
       << pattern.AsString()
       << "\" was not a path beginning in \"/\" or \"//\".";
   return SourceFile(SourceFile::SWAP_IN, &result_value);
 }
 
 // static
 std::string SubstitutionWriter::ApplyPatternToSourceAsString(
     const Settings* settings,
     const SubstitutionPattern& pattern,
     const SourceFile& source) {
   std::string result_value;
-  for (size_t i = 0; i < pattern.ranges().size(); i++) {
-    const SubstitutionPattern::Subrange& subrange = pattern.ranges()[i];
+  for (const auto& subrange : pattern.ranges()) {
     if (subrange.type == SUBSTITUTION_LITERAL) {
       result_value.append(subrange.literal);
     } else {
       result_value.append(
           GetSourceSubstitution(settings, source, subrange.type,
                                 OUTPUT_ABSOLUTE, SourceDir()));
     }
   }
   return result_value;
 }
@@ skipping 10 matching lines @@
       << "\" was not an absolute path beginning in \"//\".";
   return OutputFile(settings->build_settings(), result_as_source);
 }
 
 // static
 void SubstitutionWriter::ApplyListToSource(
     const Settings* settings,
     const SubstitutionList& list,
     const SourceFile& source,
     std::vector<SourceFile>* output) {
-  for (size_t i = 0; i < list.list().size(); i++) {
-    output->push_back(ApplyPatternToSource(
-        settings, list.list()[i], source));
-  }
+  for (const auto& item : list.list())
+    output->push_back(ApplyPatternToSource(settings, item, source));
 }
 
 // static
 void SubstitutionWriter::ApplyListToSourceAsString(
     const Settings* settings,
     const SubstitutionList& list,
     const SourceFile& source,
     std::vector<std::string>* output) {
-  for (size_t i = 0; i < list.list().size(); i++) {
-    output->push_back(ApplyPatternToSourceAsString(
-        settings, list.list()[i], source));
-  }
+  for (const auto& item : list.list())
+    output->push_back(ApplyPatternToSourceAsString(settings, item, source));
 }
 
 // static
 void SubstitutionWriter::ApplyListToSourceAsOutputFile(
     const Settings* settings,
     const SubstitutionList& list,
     const SourceFile& source,
     std::vector<OutputFile>* output) {
-  for (size_t i = 0; i < list.list().size(); i++) {
-    output->push_back(ApplyPatternToSourceAsOutputFile(
-        settings, list.list()[i], source));
-  }
+  for (const auto& item : list.list())
+    output->push_back(ApplyPatternToSourceAsOutputFile(settings, item, source));
 }
 
 // static
 void SubstitutionWriter::ApplyListToSources(
     const Settings* settings,
     const SubstitutionList& list,
     const std::vector<SourceFile>& sources,
     std::vector<SourceFile>* output) {
   output->clear();
-  for (size_t i = 0; i < sources.size(); i++)
-    ApplyListToSource(settings, list, sources[i], output);
+  for (const auto& source : sources)
+    ApplyListToSource(settings, list, source, output);
 }
 
 // static
 void SubstitutionWriter::ApplyListToSourcesAsString(
     const Settings* settings,
     const SubstitutionList& list,
     const std::vector<SourceFile>& sources,
     std::vector<std::string>* output) {
   output->clear();
-  for (size_t i = 0; i < sources.size(); i++)
-    ApplyListToSourceAsString(settings, list, sources[i], output);
+  for (const auto& source : sources)
+    ApplyListToSourceAsString(settings, list, source, output);
 }
 
 // static
 void SubstitutionWriter::ApplyListToSourcesAsOutputFile(
     const Settings* settings,
     const SubstitutionList& list,
     const std::vector<SourceFile>& sources,
     std::vector<OutputFile>* output) {
   output->clear();
-  for (size_t i = 0; i < sources.size(); i++)
-    ApplyListToSourceAsOutputFile(settings, list, sources[i], output);
+  for (const auto& source : sources)
+    ApplyListToSourceAsOutputFile(settings, list, source, output);
 }
 
 // static
 void SubstitutionWriter::WriteNinjaVariablesForSource(
     const Settings* settings,
     const SourceFile& source,
     const std::vector<SubstitutionType>& types,
     const EscapeOptions& escape_options,
     std::ostream& out) {
-  for (size_t i = 0; i < types.size(); i++) {
+  for (const auto& type : types) {
     // Don't write SOURCE since that just maps to Ninja's $in variable, which
     // is implicit in the rule.
-    if (types[i] != SUBSTITUTION_SOURCE) {
-      out << "  " << kSubstitutionNinjaNames[types[i]] << " = ";
+    if (type != SUBSTITUTION_SOURCE) {
+      out << "  " << kSubstitutionNinjaNames[type] << " = ";
         EscapeStringToStream(
             out,
-            GetSourceSubstitution(settings, source, types[i], OUTPUT_RELATIVE,
+            GetSourceSubstitution(settings, source, type, OUTPUT_RELATIVE,
                                   settings->build_settings()->build_dir()),
             escape_options);
       out << std::endl;
     }
   }
 }
 
 // static
 std::string SubstitutionWriter::GetSourceSubstitution(
     const Settings* settings,
@@ skipping 51 matching lines @@
     return to_rebase;
   return RebaseSourceAbsolutePath(to_rebase, relative_to);
 }
 
 // static
 OutputFile SubstitutionWriter::ApplyPatternToTargetAsOutputFile(
     const Target* target,
     const Tool* tool,
     const SubstitutionPattern& pattern) {
   std::string result_value;
-  for (size_t i = 0; i < pattern.ranges().size(); i++) {
-    const SubstitutionPattern::Subrange& subrange = pattern.ranges()[i];
+  for (const auto& subrange : pattern.ranges()) {
     if (subrange.type == SUBSTITUTION_LITERAL) {
       result_value.append(subrange.literal);
     } else {
       std::string subst;
       CHECK(GetTargetSubstitution(target, subrange.type, &subst));
       result_value.append(subst);
     }
   }
   return OutputFile(result_value);
 }
 
 // static
 void SubstitutionWriter::ApplyListToTargetAsOutputFile(
     const Target* target,
     const Tool* tool,
     const SubstitutionList& list,
     std::vector<OutputFile>* output) {
-  for (size_t i = 0; i < list.list().size(); i++) {
-    output->push_back(ApplyPatternToTargetAsOutputFile(
-        target, tool, list.list()[i]));
-  }
+  for (const auto& item : list.list())
+    output->push_back(ApplyPatternToTargetAsOutputFile(target, tool, item));
 }
 
 // static
 bool SubstitutionWriter::GetTargetSubstitution(
     const Target* target,
     SubstitutionType type,
     std::string* result) {
   switch (type) {
     case SUBSTITUTION_LABEL:
       // Only include the toolchain for non-default toolchains.
@@ skipping 37 matching lines @@
   GetTargetSubstitution(target, type, &result);
   return result;
 }
 
 // static
 OutputFile SubstitutionWriter::ApplyPatternToCompilerAsOutputFile(
     const Target* target,
     const SourceFile& source,
     const SubstitutionPattern& pattern) {
   OutputFile result;
-  for (size_t i = 0; i < pattern.ranges().size(); i++) {
-    const SubstitutionPattern::Subrange& subrange = pattern.ranges()[i];
+  for (const auto& subrange : pattern.ranges()) {
     if (subrange.type == SUBSTITUTION_LITERAL) {
       result.value().append(subrange.literal);
     } else {
       result.value().append(
           GetCompilerSubstitution(target, source, subrange.type));
     }
   }
   return result;
 }
 
 // static
 void SubstitutionWriter::ApplyListToCompilerAsOutputFile(
     const Target* target,
     const SourceFile& source,
     const SubstitutionList& list,
     std::vector<OutputFile>* output) {
-  for (size_t i = 0; i < list.list().size(); i++) {
-    output->push_back(ApplyPatternToCompilerAsOutputFile(
-        target, source, list.list()[i]));
-  }
+  for (const auto& item : list.list())
+    output->push_back(ApplyPatternToCompilerAsOutputFile(target, source, item));
 }
 
 // static
 std::string SubstitutionWriter::GetCompilerSubstitution(
     const Target* target,
     const SourceFile& source,
     SubstitutionType type) {
   // First try the common tool ones.
   std::string result;
   if (GetTargetSubstitution(target, type, &result))
     return result;
 
   // Fall-through to the source ones.
   return GetSourceSubstitution(
       target->settings(), source, type, OUTPUT_RELATIVE,
       target->settings()->build_settings()->build_dir());
 }
 
 // static
 OutputFile SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
     const Target* target,
     const Tool* tool,
     const SubstitutionPattern& pattern) {
   OutputFile result;
-  for (size_t i = 0; i < pattern.ranges().size(); i++) {
-    const SubstitutionPattern::Subrange& subrange = pattern.ranges()[i];
+  for (const auto& subrange : pattern.ranges()) {
     if (subrange.type == SUBSTITUTION_LITERAL) {
       result.value().append(subrange.literal);
     } else {
       result.value().append(GetLinkerSubstitution(target, tool, subrange.type));
     }
   }
   return result;
 }
 
 // static
 void SubstitutionWriter::ApplyListToLinkerAsOutputFile(
     const Target* target,
     const Tool* tool,
     const SubstitutionList& list,
     std::vector<OutputFile>* output) {
-  for (size_t i = 0; i < list.list().size(); i++) {
-    output->push_back(ApplyPatternToLinkerAsOutputFile(
-        target, tool, list.list()[i]));
-  }
+  for (const auto& item : list.list())
+    output->push_back(ApplyPatternToLinkerAsOutputFile(target, tool, item));
 }
 
 // static
 std::string SubstitutionWriter::GetLinkerSubstitution(
     const Target* target,
     const Tool* tool,
     SubstitutionType type) {
   // First try the common tool ones.
   std::string result;
   if (GetTargetSubstitution(target, type, &result))
     return result;
 
   // Fall-through to the linker-specific ones.
   switch (type) {
     case SUBSTITUTION_OUTPUT_EXTENSION:
       // Use the extension provided on the target if nonempty, otherwise
       // fall back on the default. Note that the target's output extension
       // does not include the dot but the tool's does.
       if (target->output_extension().empty())
         return tool->default_output_extension();
       return std::string(".") + target->output_extension();
 
     default:
       NOTREACHED();
       return std::string();
   }
 }