GN: Generate error if multiple rules generate same file

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"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "tools/gn/build_settings.h"
+#include "tools/gn/err.h"
 #include "tools/gn/escape.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file_manager.h"
 #include "tools/gn/ninja_utils.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/target.h"
 #include "tools/gn/trace.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 56 matching lines @@
       default_toolchain_(default_toolchain),
       default_toolchain_targets_(default_toolchain_targets),
       out_(out),
       dep_out_(dep_out),
       path_output_(build_settings->build_dir(), ESCAPE_NINJA) {
 }
 
 NinjaBuildWriter::~NinjaBuildWriter() {
 }
 
-void NinjaBuildWriter::Run() {
+bool NinjaBuildWriter::Run(Err* err) {
   WriteNinjaRules();
   WriteLinkPool();
   WriteSubninjas();
-  WritePhonyAndAllRules();
+  return WritePhonyAndAllRules(err);
 }
 
 // static
 bool NinjaBuildWriter::RunAndWriteFile(
     const BuildSettings* build_settings,
     const std::vector<const Settings*>& all_settings,
     const Toolchain* default_toolchain,
-    const std::vector<const Target*>& default_toolchain_targets) {
+    const std::vector<const Target*>& default_toolchain_targets,
+    Err* err) {
   ScopedTrace trace(TraceItem::TRACE_FILE_WRITE, "build.ninja");
 
   base::FilePath ninja_file(build_settings->GetFullPath(
       SourceFile(build_settings->build_dir().value() + "build.ninja")));
   base::CreateDirectory(ninja_file.DirName());
 
   std::ofstream file;
   file.open(FilePathToUTF8(ninja_file).c_str(),
             std::ios_base::out | std::ios_base::binary);
-  if (file.fail())
+  if (file.fail()) {
+    *err = Err(Location(), "Couldn't open build.ninja for writing");
     return false;
+  }
 
   std::ofstream depfile;
   depfile.open((FilePathToUTF8(ninja_file) + ".d").c_str(),
                std::ios_base::out | std::ios_base::binary);
-  if (depfile.fail())
+  if (depfile.fail()) {
+    *err = Err(Location(), "Couldn't open depfile for writing");
     return false;
+  }
 
   NinjaBuildWriter gen(build_settings, all_settings, default_toolchain,
                        default_toolchain_targets, file, depfile);
-  gen.Run();
-  return true;
+  return gen.Run(err);
 }
 
 void NinjaBuildWriter::WriteNinjaRules() {
   out_ << "rule gn\n";
   out_ << "  command = " << GetSelfInvocationCommand(build_settings_) << "\n";
   out_ << "  description = Regenerating ninja files\n\n";
 
   // This rule will regenerate the ninja files when any input file has changed.
   out_ << "build build.ninja: gn\n"
        << "  generator = 1\n"
@@ skipping 25 matching lines @@
 
 void NinjaBuildWriter::WriteSubninjas() {
   for (size_t i = 0; i < all_settings_.size(); i++) {
     out_ << "subninja ";
     path_output_.WriteFile(out_, GetNinjaFileForToolchain(all_settings_[i]));
     out_ << std::endl;
   }
   out_ << std::endl;
 }
 
-void NinjaBuildWriter::WritePhonyAndAllRules() {
+bool NinjaBuildWriter::WritePhonyAndAllRules(Err* err) {
   std::string all_rules;
 
   // 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::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];
     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);
   }
 
   for (size_t i = 0; i < default_toolchain_targets_.size(); i++) {
     const Target* target = default_toolchain_targets_[i];
     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);
 
     // 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());
@@ skipping 20 matching lines @@
       const Target* target = toplevel_targets[i];
       WritePhonyRule(target, target->dependency_output_file(),
                      target->label().name());
     }
   }
 
   if (!all_rules.empty()) {
     out_ << "\nbuild all: phony " << all_rules << std::endl;
     out_ << "default all" << std::endl;
   }
+  return true;
 }
 
 void NinjaBuildWriter::WritePhonyRule(const Target* target,
                                       const OutputFile& target_file,
                                       const std::string& phony_name) {
   if (target_file.value() == phony_name)
     return;  // No need for a phony rule.
 
   EscapeOptions ninja_escape;
   ninja_escape.mode = ESCAPE_NINJA;
 
   // Escape for special chars Ninja will handle.
   std::string escaped = EscapeString(phony_name, ninja_escape, NULL);
 
   out_ << "build " << escaped << ": phony ";
   path_output_.WriteFile(out_, target_file);
   out_ << std::endl;
 }