🌱 GN: Look at all target outputs when detecting duplicates

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 96 matching lines @@
   }
   return false;
 }
 
 // Given an output that appears more than once, generates an error message
 // that describes the problem and which targets generate it.
 Err GetDuplicateOutputError(const std::vector<const Target*>& all_targets,
                             const OutputFile& bad_output) {
   std::vector<const Target*> matches;
   for (const Target* target : all_targets) {
-    if (GetTargetOutputFile(target) == bad_output)
-      matches.push_back(target);
+    for (const auto& output : target->computed_outputs()) {
+      if (output == bad_output) {
+        matches.push_back(target);
+        break;
+      }
+    }
   }
 
   // There should always be at least two targets generating this file for this
   // function to be called in the first place.
   DCHECK(matches.size() >= 2);
   std::string matches_string;
   for (const Target* target : matches)
     matches_string += "  " + target->label().GetUserVisibleName(false) + "\n";
 
   Err result(matches[0]->defined_from(), "Duplicate output file.",
       "Two or more targets generate the same output:\n  " +
-      bad_output.value() + "\n"
-      "This is normally the result of either overriding the output name or\n"
-      "having two shared libraries or executables in different directories\n"
-      "with the same name (since all such targets will be written to the root\n"
-      "output directory).\n\nCollisions:\n" + matches_string);
+      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;
 }
 
 }  // namespace
 
 NinjaBuildWriter::NinjaBuildWriter(
     const BuildSettings* build_settings,
     const std::vector<const Settings*>& all_settings,
@@ skipping 142 matching lines @@
 
     // 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 = GetTargetOutputFile(target);
-    if (!target_files.insert(target_file.value()).second) {
-      *err = GetDuplicateOutputError(default_toolchain_targets_, target_file);
-      return false;
+    for (const auto& output : target->computed_outputs()) {
+      if (!target_files.insert(output.value()).second) {
+        *err = GetDuplicateOutputError(default_toolchain_targets_, output);
+        return false;
+      }
     }
 
+    OutputFile target_file = GetTargetOutputFile(target);
     // 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, &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);
@@ skipping 79 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_file);
   out_ << std::endl;
 }