tools/gn: Convert for loops to use the new range-based loops in C++11.

range-based loops is one of the C++11 allowed features. See
https://chromium-cpp.appspot.com/ and
https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/hpzz4EqbVmc.

This patch was generated with the following command lines:

$ ninja -C out/Debug -t compdb cxx > out/Debug/compile_commands.json
$ cd out/Debug
$ find ../../tools/gn -name '*.cc'  | xargs -n 16 -P 32 \
~/src/repos/llvm/build/bin/clang-modernize -loop-convert -p . -include \
tools/gn -format -style=Chromium
$ ninja gn gn_unittests
$ ./gn_unittests

BUG=None
TEST=gn && gn_unittests
R=brettw@chromium.org

Review URL: https://codereview.chromium.org/986113002

Cr-Commit-Position: refs/heads/master@{#322177}

tools/gn/command_clean.cc

@@ -30,10 +30,10 @@ std::string ExtractGNBuildCommands(const base::FilePath& build_ninja_file) {
 
   std::string result;
   int num_blank_lines = 0;
-  for (size_t i = 0; i < lines.size(); ++i) {
-    result += lines[i];
+  for (const auto& line : lines) {
+    result += line;
     result += "\n";
-    if (lines[i].empty()) {
+    if (line.empty()) {
       ++num_blank_lines;
     }
     if (num_blank_lines == 2)

tools/gn/command_desc.cc

@@ -257,9 +257,9 @@ void PrintConfigsVector(const Target* target,
     OutputString("\n" + heading + " (in order applying):\n");
 
   Label toolchain_label = target->label().GetToolchainLabel();
-  for (size_t i = 0; i < configs.size(); i++) {
-    OutputString("  " +
-        configs[i].label.GetUserVisibleName(toolchain_label) + "\n");
+  for (const auto& config : configs) {
+    OutputString("  " + config.label.GetUserVisibleName(toolchain_label) +
+                 "\n");
   }
 }
 
@@ -275,9 +275,9 @@ void PrintConfigsVector(const Target* target,
     OutputString("\n" + heading + " (in order applying):\n");
 
   Label toolchain_label = target->label().GetToolchainLabel();
-  for (size_t i = 0; i < configs.size(); i++) {
-    OutputString("  " +
-        configs[i].label.GetUserVisibleName(toolchain_label) + "\n");
+  for (const auto& config : configs) {
+    OutputString("  " + config.label.GetUserVisibleName(toolchain_label) +
+                 "\n");
   }
 }
 
@@ -310,8 +310,8 @@ void PrintFileList(const Target::FileList& files,
 
   Target::FileList sorted = files;
   std::sort(sorted.begin(), sorted.end());
-  for (size_t i = 0; i < sorted.size(); i++)
-    OutputString(indent + sorted[i].value() + "\n");
+  for (const auto& elem : sorted)
+    OutputString(indent + elem.value() + "\n");
 }
 
 void PrintSources(const Target* target, bool display_header) {
@@ -328,11 +328,8 @@ void PrintOutputs(const Target* target, bool display_header) {
 
   if (target->output_type() == Target::ACTION) {
     // Action, print out outputs, don't apply sources to it.
-    for (size_t i = 0; i < target->action_values().outputs().list().size();
-         i++) {
-      OutputString("  " +
-                   target->action_values().outputs().list()[i].AsString() +
-                   "\n");
+    for (const auto& elem : target->action_values().outputs().list()) {
+      OutputString("  " + elem.AsString() + "\n");
     }
   } else {
     const SubstitutionList& outputs = target->action_values().outputs();
@@ -340,8 +337,8 @@ void PrintOutputs(const Target* target, bool display_header) {
       // Display the pattern and resolved pattern separately, since there are
       // subtitutions used.
       OutputString("  Output pattern:\n");
-      for (size_t i = 0; i < outputs.list().size(); i++)
-        OutputString("    " + outputs.list()[i].AsString() + "\n");
+      for (const auto& elem : outputs.list())
+        OutputString("    " + elem.AsString() + "\n");
 
       // Now display what that resolves to given the sources.
       OutputString("\n  Resolved output file list:\n");
@@ -364,9 +361,8 @@ void PrintScript(const Target* target, bool display_header) {
 void PrintArgs(const Target* target, bool display_header) {
   if (display_header)
     OutputString("\nargs:\n");
-  for (size_t i = 0; i < target->action_values().args().list().size(); i++) {
-    OutputString("  " +
-                 target->action_values().args().list()[i].AsString() + "\n");
+  for (const auto& elem : target->action_values().args().list()) {
+    OutputString("  " + elem.AsString() + "\n");
   }
 }
 

tools/gn/err.cc

@@ -64,8 +64,8 @@ void OutputHighlighedPosition(const Location& location,
     highlight[i] = ' ';
 
   // Highlight all the ranges on the line.
-  for (size_t i = 0; i < ranges.size(); i++)
-    FillRangeOnLine(ranges[i], location.line_number(), &highlight);
+  for (const auto& range : ranges)
+    FillRangeOnLine(range, location.line_number(), &highlight);
 
   // Allow the marker to be one past the end of the line for marking the end.
   highlight.push_back(' ');

tools/gn/escape.cc

@@ -44,18 +44,18 @@ void EscapeStringToString_Ninja(const base::StringPiece& str,
                                 const EscapeOptions& options,
                                 DestString* dest,
                                 bool* needed_quoting) {
-  for (size_t i = 0; i < str.size(); i++)
-    NinjaEscapeChar(str[i], dest);
+  for (const auto& elem : str)
+    NinjaEscapeChar(elem, dest);
 }
 
 template<typename DestString>
 void EscapeStringToString_NinjaPreformatted(const base::StringPiece& str,
                                             DestString* dest) {
   // Only Ninja-escape $.
-  for (size_t i = 0; i < str.size(); i++) {
-    if (str[i] == '$')
+  for (const auto& elem : str) {
+    if (elem == '$')
       dest->push_back('$');
-    dest->push_back(str[i]);
+    dest->push_back(elem);
   }
 }
 
@@ -118,26 +118,26 @@ void EscapeStringToString_PosixNinjaFork(const base::StringPiece& str,
                                          const EscapeOptions& options,
                                          DestString* dest,
                                          bool* needed_quoting) {
-  for (size_t i = 0; i < str.size(); i++) {
-    if (str[i] == '$' || str[i] == ' ') {
+  for (const auto& elem : str) {
+    if (elem == '$' || elem == ' ') {
       // Space and $ are special to both Ninja and the shell. '$' escape for
       // Ninja, then backslash-escape for the shell.
       dest->push_back('\\');
       dest->push_back('$');
-      dest->push_back(str[i]);
-    } else if (str[i] == ':') {
+      dest->push_back(elem);
+    } else if (elem == ':') {
       // Colon is the only other Ninja special char, which is not special to
       // the shell.
       dest->push_back('$');
       dest->push_back(':');
-    } else if (static_cast<unsigned>(str[i]) >= 0x80 ||
-               !kShellValid[static_cast<int>(str[i])]) {
+    } else if (static_cast<unsigned>(elem) >= 0x80 ||
+               !kShellValid[static_cast<int>(elem)]) {
       // All other invalid shell chars get backslash-escaped.
       dest->push_back('\\');
-      dest->push_back(str[i]);
+      dest->push_back(elem);
     } else {
       // Everything else is a literal.
-      dest->push_back(str[i]);
+      dest->push_back(elem);
     }
   }
 }

tools/gn/exec_process.cc

@@ -194,8 +194,8 @@ bool ExecProcess(const base::CommandLine& cmdline,
         // Adding another element here? Remeber to increase the argument to
         // reserve(), above.
 
-        for (size_t i = 0; i < fd_shuffle1.size(); ++i)
-          fd_shuffle2.push_back(fd_shuffle1[i]);
+        for (const auto& elem : fd_shuffle1)
+          fd_shuffle2.push_back(elem);
 
         if (!ShuffleFileDescriptors(&fd_shuffle1))
           _exit(127);

tools/gn/generate_test_gn_data.cc

@@ -30,8 +30,8 @@ std::string FilePathToUTF8(const base::FilePath& path) {
 
 base::FilePath RepoPathToPathName(const std::vector<int>& repo_path) {
   base::FilePath ret;
-  for (size_t i = 0; i < repo_path.size(); i++) {
-    ret = ret.Append(UTF8ToFilePath(base::IntToString(repo_path[i])));
+  for (const auto& elem : repo_path) {
+    ret = ret.Append(UTF8ToFilePath(base::IntToString(elem)));
   }
   return ret;
 }
@@ -58,9 +58,9 @@ std::string RepoPathToTargetName(const std::vector<int>& repo_path,
 std::string RepoPathToFullTargetName(const std::vector<int>& repo_path,
                                  int target_index) {
   std::string ret;
-  for (size_t i = 0; i < repo_path.size(); i++) {
+  for (const auto& elem : repo_path) {
     ret.push_back('/');
-    ret.append(base::IntToString(repo_path[i]));
+    ret.append(base::IntToString(elem));
   }
 
   ret += ":" + RepoPathToTargetName(repo_path, target_index);

tools/gn/header_checker.cc

@@ -330,10 +330,10 @@ bool HeaderChecker::CheckInclude(const Target* from_target,
   Err last_error;
 
   bool found_dependency = false;
-  for (size_t i = 0; i < targets.size(); i++) {
+  for (const auto& target : targets) {
     // We always allow source files in a target to include headers also in that
     // target.
-    const Target* to_target = targets[i].target;
+    const Target* to_target = target.target;
     if (to_target == from_target)
       return true;
 
@@ -357,20 +357,19 @@ bool HeaderChecker::CheckInclude(const Target* from_target,
 
       found_dependency = true;
 
-      if (targets[i].is_public && is_permitted_chain) {
+      if (target.is_public && is_permitted_chain) {
         // This one is OK, we're done.
         last_error = Err();
         break;
       }
 
       // Diagnose the error.
-      if (!targets[i].is_public) {
+      if (!target.is_public) {
         // Danger: must call CreatePersistentRange to put in Err.
-        last_error = Err(
-            CreatePersistentRange(source_file, range),
-            "Including a private header.",
-            "This file is private to the target " +
-                targets[i].target->label().GetUserVisibleName(false));
+        last_error = Err(CreatePersistentRange(source_file, range),
+                         "Including a private header.",
+                         "This file is private to the target " +
+                             target.target->label().GetUserVisibleName(false));
       } else if (!is_permitted_chain) {
         last_error = Err(
             CreatePersistentRange(source_file, range),

tools/gn/ninja_binary_target_writer.cc

@@ -441,10 +441,9 @@ void NinjaBinaryTargetWriter::WriteOrderOnlyDependencies(
     out_ << " ||";
 
     // Non-linkable targets.
-    for (size_t i = 0; i < non_linkable_deps.size(); i++) {
+    for (const auto& non_linkable_dep : non_linkable_deps) {
       out_ << " ";
-      path_output_.WriteFile(
-          out_, non_linkable_deps[i]->dependency_output_file());
+      path_output_.WriteFile(out_, non_linkable_dep->dependency_output_file());
     }
   }
 }

tools/gn/ninja_build_writer.cc

@@ -157,13 +157,13 @@ void NinjaBuildWriter::WriteNinjaRules() {
   dep_out_ << "build.ninja:";
   std::vector<base::FilePath> input_files;
   g_scheduler->input_file_manager()->GetAllPhysicalInputFileNames(&input_files);
-  for (size_t i = 0; i < input_files.size(); i++)
-    dep_out_ << " " << FilePathToUTF8(input_files[i]);
+  for (const auto& input_file : input_files)
+    dep_out_ << " " << FilePathToUTF8(input_file);
 
   // Other files read by the build.
   std::vector<base::FilePath> other_files = g_scheduler->GetGenDependencies();
-  for (size_t i = 0; i < other_files.size(); i++)
-    dep_out_ << " " << FilePathToUTF8(other_files[i]);
+  for (const auto& other_file : other_files)
+    dep_out_ << " " << FilePathToUTF8(other_file);
 
   out_ << std::endl;
 }
@@ -175,9 +175,9 @@ void NinjaBuildWriter::WriteLinkPool() {
 }
 
 void NinjaBuildWriter::WriteSubninjas() {
-  for (size_t i = 0; i < all_settings_.size(); i++) {
+  for (const auto& elem : all_settings_) {
     out_ << "subninja ";
-    path_output_.WriteFile(out_, GetNinjaFileForToolchain(all_settings_[i]));
+    path_output_.WriteFile(out_, GetNinjaFileForToolchain(elem));
     out_ << std::endl;
   }
   out_ << std::endl;
@@ -193,8 +193,7 @@ bool NinjaBuildWriter::WritePhonyAndAllRules(Err* err) {
   std::map<std::string, int> small_name_count;
   std::vector<const Target*> toplevel_targets;
   base::hash_set<std::string> target_files;
-  for (size_t i = 0; i < default_toolchain_targets_.size(); i++) {
-    const Target* target = default_toolchain_targets_[i];
+  for (const auto& target : default_toolchain_targets_) {
     const Label& label = target->label();
     small_name_count[label.name()]++;
 
@@ -211,8 +210,7 @@ bool NinjaBuildWriter::WritePhonyAndAllRules(Err* err) {
       toplevel_targets.push_back(target);
   }
 
-  for (size_t i = 0; i < default_toolchain_targets_.size(); i++) {
-    const Target* target = default_toolchain_targets_[i];
+  for (const auto& target : default_toolchain_targets_) {
     const Label& label = target->label();
     OutputFile target_file(target->dependency_output_file());
     // The output files may have leading "./" so normalize those away.
@@ -249,11 +247,10 @@ bool NinjaBuildWriter::WritePhonyAndAllRules(Err* err) {
 
   // Pick up phony rules for the toplevel targets with non-unique names (which
   // would have been skipped in the above loop).
-  for (size_t i = 0; i < toplevel_targets.size(); i++) {
-    if (small_name_count[toplevel_targets[i]->label().name()] > 1) {
-      const Target* target = toplevel_targets[i];
-      WritePhonyRule(target, target->dependency_output_file(),
-                     target->label().name());
+  for (const auto& toplevel_target : toplevel_targets) {
+    if (small_name_count[toplevel_target->label().name()] > 1) {
+      WritePhonyRule(toplevel_target, toplevel_target->dependency_output_file(),
+                     toplevel_target->label().name());
     }
   }
 
@@ -261,8 +258,8 @@ bool NinjaBuildWriter::WritePhonyAndAllRules(Err* err) {
   // target (rather than building 'all' by default). By convention
   // we use group("default") but it doesn't have to be a group.
   bool default_target_exists = false;
-  for (size_t i = 0; i < default_toolchain_targets_.size(); i++) {
-    const Label& label = default_toolchain_targets_[i]->label();
+  for (const auto& target : default_toolchain_targets_) {
+    const Label& label = target->label();
     if (label.dir().value() == "//" && label.name() == "default")
       default_target_exists = true;
   }

tools/gn/ninja_copy_target_writer.cc

@@ -100,9 +100,7 @@ void NinjaCopyTargetWriter::WriteCopyRules(
   // where a command might need to make sure something else runs before it runs
   // to avoid conflicts. Such cases should be avoided where possible, but
   // sometimes that's not possible.
-  for (size_t i = 0; i < target_->sources().size(); i++) {
-    const SourceFile& input_file = target_->sources()[i];
-
+  for (const auto& input_file : target_->sources()) {
     OutputFile output_file =
         SubstitutionWriter::ApplyPatternToSourceAsOutputFile(
             target_->settings(), output_subst, input_file);

tools/gn/ninja_target_writer.cc

@@ -195,16 +195,14 @@ OutputFile NinjaTargetWriter::WriteInputDepsStampAndGetDep(
   }
 
   // Input files are order-only deps.
-  const Target::FileList& prereqs = target_->inputs();
-  for (size_t i = 0; i < prereqs.size(); i++) {
+  for (const auto& input : target_->inputs()) {
     out_ << " ";
-    path_output_.WriteFile(out_, prereqs[i]);
+    path_output_.WriteFile(out_, input);
   }
   if (list_sources_as_input_deps) {
-    const Target::FileList& sources = target_->sources();
-    for (size_t i = 0; i < sources.size(); i++) {
+    for (const auto& source : target_->sources()) {
       out_ << " ";
-      path_output_.WriteFile(out_, sources[i]);
+      path_output_.WriteFile(out_, source);
     }
   }
 
@@ -225,8 +223,8 @@ OutputFile NinjaTargetWriter::WriteInputDepsStampAndGetDep(
   // toolchains often have more than one dependency, we could consider writing
   // a toolchain-specific stamp file and only include the stamp here.
   const LabelTargetVector& toolchain_deps = target_->toolchain()->deps();
-  for (size_t i = 0; i < toolchain_deps.size(); i++)
-    unique_deps.insert(toolchain_deps[i].ptr);
+  for (const auto& toolchain_dep : toolchain_deps)
+    unique_deps.insert(toolchain_dep.ptr);
 
   for (const auto& dep : unique_deps) {
     DCHECK(!dep->dependency_output_file().value().empty());

tools/gn/ninja_toolchain_writer.cc

@@ -128,9 +128,9 @@ void NinjaToolchainWriter::WriteRulePattern(const char* name,
 
 void NinjaToolchainWriter::WriteSubninjas() {
   // Write subninja commands for each generated target.
-  for (size_t i = 0; i < targets_.size(); i++) {
-    OutputFile ninja_file(targets_[i]->settings()->build_settings(),
-                          GetNinjaFileForTarget(targets_[i]));
+  for (const auto& target : targets_) {
+    OutputFile ninja_file(target->settings()->build_settings(),
+                          GetNinjaFileForTarget(target));
     out_ << "subninja ";
     path_output_.WriteFile(out_, ninja_file);
     out_ << std::endl;

tools/gn/ninja_writer.cc

@@ -52,11 +52,11 @@ bool NinjaWriter::WriteToolchains(std::vector<const Settings*>* all_settings,
   CategorizedMap categorized;
 
   std::vector<const BuilderRecord*> all_records = builder_->GetAllRecords();
-  for (size_t i = 0; i < all_records.size(); i++) {
-    if (all_records[i]->type() == BuilderRecord::ITEM_TARGET &&
-        all_records[i]->should_generate()) {
-      categorized[all_records[i]->label().GetToolchainLabel()].push_back(
-          all_records[i]->item()->AsTarget());
+  for (const auto& all_record : all_records) {
+    if (all_record->type() == BuilderRecord::ITEM_TARGET &&
+        all_record->should_generate()) {
+      categorized[all_record->label().GetToolchainLabel()].push_back(
+          all_record->item()->AsTarget());
       }
   }
   if (categorized.empty()) {

tools/gn/operators.cc

@@ -98,10 +98,10 @@ void RemoveMatchesFromList(const BinaryOpNode* op_node,
     }
 
     case Value::LIST:  // Filter out each individual thing.
-      for (size_t i = 0; i < to_remove.list_value().size(); i++) {
+      for (const auto& elem : to_remove.list_value()) {
         // TODO(brettw) if the nested item is a list, we may want to search
         // for the literal list rather than remote the items in it.
-        RemoveMatchesFromList(op_node, list, to_remove.list_value()[i], err);
+        RemoveMatchesFromList(op_node, list, elem, err);
         if (err->has_error())
           return;
       }

tools/gn/pattern.cc

@@ -167,16 +167,16 @@ void PatternList::SetFromValue(const Value& v, Err* err) {
   }
 
   const std::vector<Value>& list = v.list_value();
-  for (size_t i = 0; i < list.size(); i++) {
-    if (!list[i].VerifyTypeIs(Value::STRING, err))
+  for (const auto& elem : list) {
+    if (!elem.VerifyTypeIs(Value::STRING, err))
       return;
-    patterns_.push_back(Pattern(list[i].string_value()));
+    patterns_.push_back(Pattern(elem.string_value()));
   }
 }
 
 bool PatternList::MatchesString(const std::string& s) const {
-  for (size_t i = 0; i < patterns_.size(); i++) {
-    if (patterns_[i].MatchesString(s))
+  for (const auto& pattern : patterns_) {
+    if (pattern.MatchesString(s))
       return true;
   }
   return false;

tools/gn/standard_out.cc

@@ -179,12 +179,12 @@ void PrintLongHelp(const std::string& text) {
 
     // Check for a comment.
     TextDecoration dec = DECORATION_NONE;
-    for (size_t char_i = 0; char_i < line.size(); char_i++) {
-      if (line[char_i] == '#') {
+    for (const auto& elem : line) {
+      if (elem == '#') {
         // Got a comment, draw dimmed.
         dec = DECORATION_DIM;
         break;
-      } else if (line[char_i] != ' ') {
+      } else if (elem != ' ') {
         break;
       }
     }

tools/gn/substitution_pattern.cc

@@ -101,19 +101,19 @@ SubstitutionPattern SubstitutionPattern::MakeForTest(const char* str) {
 
 std::string SubstitutionPattern::AsString() const {
   std::string result;
-  for (size_t i = 0; i < ranges_.size(); i++) {
-    if (ranges_[i].type == SUBSTITUTION_LITERAL)
-      result.append(ranges_[i].literal);
+  for (const auto& elem : ranges_) {
+    if (elem.type == SUBSTITUTION_LITERAL)
+      result.append(elem.literal);
     else
-      result.append(kSubstitutionNames[ranges_[i].type]);
+      result.append(kSubstitutionNames[elem.type]);
   }
   return result;
 }
 
 void SubstitutionPattern::FillRequiredTypes(SubstitutionBits* bits) const {
-  for (size_t i = 0; i < ranges_.size(); i++) {
-    if (ranges_[i].type != SUBSTITUTION_LITERAL)
-      bits->used[static_cast<size_t>(ranges_[i].type)] = true;
+  for (const auto& elem : ranges_) {
+    if (elem.type != SUBSTITUTION_LITERAL)
+      bits->used[static_cast<size_t>(elem.type)] = true;
   }
 }
 

tools/gn/toolchain.cc

@@ -89,9 +89,9 @@ void Toolchain::SetTool(ToolType type, scoped_ptr<Tool> t) {
 
 void Toolchain::ToolchainSetupComplete() {
   // Collect required bits from all tools.
-  for (size_t i = 0; i < TYPE_NUMTYPES; i++) {
-    if (tools_[i])
-      substitution_bits_.MergeFrom(tools_[i]->substitution_bits());
+  for (const auto& tool : tools_) {
+    if (tool)
+      substitution_bits_.MergeFrom(tool->substitution_bits());
   }
 
   setup_complete_ = true;