GN: Don't generate phony rules called "all".

tools/gn/ninja_build_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_build_writer.h"
 
 #include <fstream>
 #include <map>
 
 #include "base/command_line.h"
@@ skipping 168 matching lines @@
     out_ << "subninja ";
     path_output_.WriteFile(out_, GetNinjaFileForToolchain(elem));
     out_ << std::endl;
   }
   out_ << std::endl;
 }
 
 bool NinjaBuildWriter::WritePhonyAndAllRules(Err* err) {
   std::string all_rules;
 
+  // Track rules as we generate them so we don't accidentally write a phony
+  // rule that collides with something else.
+  // GN internally generates an "all" target, so don't duplicate it.
+  std::set<std::string> written_rules;
+  written_rules.insert("all");
+
   // Write phony rules for all uniquely-named targets in the default toolchain.
   // Don't do other toolchains or we'll get naming conflicts, and if the name
   // isn't unique, also skip it. The exception is for the toplevel targets
   // which we also find.
   std::map<std::string, int> small_name_count;
   std::map<std::string, int> exe_count;
   std::vector<const Target*> toplevel_targets;
   base::hash_set<std::string> target_files;
   for (const auto& target : default_toolchain_targets_) {
     const Label& label = target->label();
     small_name_count[label.name()]++;
 
     // Look for targets with a name of the form
     //   dir = "//foo/", name = "foo"
     // i.e. where the target name matches the top level directory. We will
     // always write phony rules for these even if there is another target with
     // the same short name.
     const std::string& dir_string = label.dir().value();
     if (dir_string.size() == label.name().size() + 3 &&  // Size matches.
         dir_string[0] == '/' && dir_string[1] == '/' &&  // "//" at beginning.
         dir_string[dir_string.size() - 1] == '/' &&  // "/" at end.
         dir_string.compare(2, label.name().size(), label.name()) == 0)
       toplevel_targets.push_back(target);
 
     // Look for executables; later we will generate phony rules for them
     // even if there are non-executable targets with the same name.
     if (target->output_type() == Target::EXECUTABLE)
       exe_count[label.name()]++;
+
+    // Add the files to the list of generated targets so we don't write phony
+    // rules that collide.
+    std::string target_file(target->dependency_output_file().value());
+    NormalizePath(&target_file);
+    written_rules.insert(target_file);
   }
 
   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.
     NormalizePath(&target_file.value());
     if (!target_files.insert(target_file.value()).second) {
       *err = Err(Location(), "Duplicate rules for " + target_file.value());
       return false;
     }
 
     // Write the long name "foo/bar:baz" for the target "//foo/bar:baz".
     std::string long_name = label.GetUserVisibleName(false);
     base::TrimString(long_name, "/", &long_name);
-    WritePhonyRule(target, target_file, long_name);
+    WritePhonyRule(target, target_file, long_name, &written_rules);
 
     // Write the directory name with no target name if they match
     // (e.g. "//foo/bar:bar" -> "foo/bar").
     if (FindLastDirComponent(label.dir()) == label.name()) {
       std::string medium_name =  DirectoryWithNoLastSlash(label.dir());
       base::TrimString(medium_name, "/", &medium_name);
       // That may have generated a name the same as the short name of the
       // target which we already wrote.
       if (medium_name != label.name())
-        WritePhonyRule(target, target_file, medium_name);
+        WritePhonyRule(target, target_file, medium_name, &written_rules);
     }
 
     // Write short names for ones which are either completely unique or there
     // at least only one of them in the default toolchain that is an exe.
     if (small_name_count[label.name()] == 1 ||
         (target->output_type() == Target::EXECUTABLE &&
          exe_count[label.name()] == 1)) {
-      WritePhonyRule(target, target_file, label.name());
+      WritePhonyRule(target, target_file, label.name(), &written_rules);
     }
 
     if (!all_rules.empty())
       all_rules.append(" $\n    ");
     all_rules.append(target_file.value());
   }
 
   // Pick up phony rules for the toplevel targets with non-unique names (which
   // would have been skipped in the above loop).
   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());
+                     toplevel_target->label().name(), &written_rules);
     }
   }
 
   // Figure out if the BUILD file wants to declare a custom "default"
   // 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 (const auto& target : default_toolchain_targets_) {
     const Label& label = target->label();
     if (label.dir().value() == "//" && label.name() == "default")
       default_target_exists = true;
   }
 
   if (!all_rules.empty()) {
     out_ << "\nbuild all: phony " << all_rules << std::endl;
   }
 
   if (default_target_exists) {
     out_ << "default default" << std::endl;
   } else if (!all_rules.empty()) {
     out_ << "default all" << std::endl;
   }
 
   return true;
 }
 
 void NinjaBuildWriter::WritePhonyRule(const Target* target,
                                       const OutputFile& target_file,
-                                      const std::string& phony_name) {
+                                      const std::string& phony_name,
+                                      std::set<std::string>* written_rules) {
   if (target_file.value() == phony_name)
     return;  // No need for a phony rule.
 
+  if (written_rules->find(phony_name) != written_rules->end())
+    return;  // Already exists.
+  written_rules->insert(phony_name);
+
   EscapeOptions ninja_escape;
   ninja_escape.mode = ESCAPE_NINJA;
 
   // Escape for special chars Ninja will handle.
   std::string escaped = EscapeString(phony_name, ninja_escape, nullptr);
 
   out_ << "build " << escaped << ": phony ";
   path_output_.WriteFile(out_, target_file);
   out_ << std::endl;
 }