gn: Diag on distinct toolchains with the same name.

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 <stddef.h>
 
 #include <fstream>
 #include <map>
@@ skipping 112 matching lines @@
       "Two or more targets generate the same output:\n  " +
       bad_output.value() + "\n\n"
       "This is can often be fixed by changing one of the target names, or by \n"
       "setting an output_name on one of them.\n"
       "\nCollisions:\n" + matches_string);
   for (size_t i = 1; i < matches.size(); i++)
     result.AppendSubErr(Err(matches[i]->defined_from(), "Collision."));
   return result;
 }
 
+// Given two toolchains with the same name, generates an error message
+// that describes the problem.
+Err GetDuplicateToolchainError(const SourceFile& source_file,
+                               const Toolchain* previous_toolchain,
+                               const Toolchain* toolchain) {
+  Err result(toolchain->defined_from(), "Duplicate toolchain.",
+      "Two or more toolchains write to the same directory:\n  " +
+      source_file.GetDir().value() + "\n\n"
+      "This can be fixed by making sure that distinct toolchains have\n"
+      "distinct names.\n");
+  result.AppendSubErr(
+      Err(previous_toolchain->defined_from(), "Previous toolchain."));
+  return result;
+}
+
 }  // namespace
 
 NinjaBuildWriter::NinjaBuildWriter(
     const BuildSettings* build_settings,
     const std::unordered_map<const Settings*, const Toolchain*>&
         used_toolchains,
     const Toolchain* default_toolchain,
     const std::vector<const Target*>& default_toolchain_targets,
     std::ostream& out,
     std::ostream& dep_out)
     : build_settings_(build_settings),
       used_toolchains_(used_toolchains),
       default_toolchain_(default_toolchain),
       default_toolchain_targets_(default_toolchain_targets),
       out_(out),
       dep_out_(dep_out),
       path_output_(build_settings->build_dir(),
                    build_settings->root_path_utf8(),
                    ESCAPE_NINJA) {}
 
 NinjaBuildWriter::~NinjaBuildWriter() {
 }
 
 bool NinjaBuildWriter::Run(Err* err) {
   WriteNinjaRules();
   WriteAllPools();
-  WriteSubninjas();
-  return WritePhonyAndAllRules(err);
+  return WriteSubninjas(err) && WritePhonyAndAllRules(err);
 }
 
 // static
 bool NinjaBuildWriter::RunAndWriteFile(
     const BuildSettings* build_settings,
     const Builder& builder,
     Err* err) {
   ScopedTrace trace(TraceItem::TRACE_FILE_WRITE, "build.ninja");
 
   std::vector<const Target*> all_targets = builder.GetAllResolvedTargets();
@@ skipping 109 matching lines @@
             [&pool_name](const Pool* a, const Pool* b) {
               return pool_name(a) < pool_name(b);
             });
   for (const Pool* pool : sorted_pools) {
     out_ << "pool " << pool_name(pool) << std::endl
          << "  depth = " << pool->depth() << std::endl
          << std::endl;
   }
 }
 
-void NinjaBuildWriter::WriteSubninjas() {
+bool NinjaBuildWriter::WriteSubninjas(Err* err) {
   // Write toolchains sorted by their name, to make output deterministic.
   std::vector<std::pair<const Settings*, const Toolchain*>> sorted_settings(
       used_toolchains_.begin(), used_toolchains_.end());
   std::sort(sorted_settings.begin(), sorted_settings.end(),
             [this](const std::pair<const Settings*, const Toolchain*>& a,
                    const std::pair<const Settings*, const Toolchain*>& b) {
               // Always put the default toolchain first.
               if (b.second == default_toolchain_)
                 return false;
               if (a.second == default_toolchain_)
                 return true;
               return GetNinjaFileForToolchain(a.first) <
                      GetNinjaFileForToolchain(b.first);
             });
+
+  SourceFile previous_subninja;
+  const Toolchain* previous_toolchain = nullptr;
+
   for (const auto& pair : sorted_settings) {
+    SourceFile subninja = GetNinjaFileForToolchain(pair.first);
+
+    // Since the toolchains are sorted, comparing to the previous subninja is
+    // enough to find duplicates.
+    if (subninja == previous_subninja) {
+      *err =
+          GetDuplicateToolchainError(subninja, previous_toolchain, pair.second);
+      return false;
+    }
+
     out_ << "subninja ";
-    path_output_.WriteFile(out_, GetNinjaFileForToolchain(pair.first));
+    path_output_.WriteFile(out_, subninja);
     out_ << std::endl;
+    previous_subninja = subninja;
+    previous_toolchain = pair.second;
   }
   out_ << std::endl;
+  return true;
 }
 
 bool NinjaBuildWriter::WritePhonyAndAllRules(Err* err) {
   // 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.
   base::hash_set<std::string> written_rules;
   written_rules.insert("all");
 
   // Set if we encounter a target named "//:default".
@@ skipping 153 matching lines @@
   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->dependency_output_file());
   out_ << std::endl;
 }