GN: Add ability to specify a depfile for custom targets.

tools/gn/ninja_script_target_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_script_target_writer.h"
 
 #include "base/strings/string_util.h"
 #include "tools/gn/err.h"
 #include "tools/gn/file_template.h"
 #include "tools/gn/string_utils.h"
@@ skipping 18 matching lines @@
   // Collects all output files for writing below.
   std::vector<OutputFile> output_files;
 
   if (has_sources()) {
     // Write separate build lines for each input source file.
     WriteSourceRules(custom_rule_name, implicit_deps, args_template,
                      &output_files);
   } else {
     // No sources, write a rule that invokes the script once with the
     // outputs as outputs, and the data as inputs.
-    out_ << "build";
+    out_ << "build ";

[brettw, 2013/11/04 05:22:14]

I've been standardizing on the guy who's appending something writes the space.
You can keep WriteDepfile not writing a space if you want, but then write the
extra one inside the if block below, or else you'll get two spaces when there's
no depfile.

[koz (OOO until 15th September), 2013/11/06 07:29:11]

Done.

+    if (target_->script_values().has_depfile())
+      WriteDepfile(SourceFile());
     const Target::FileList& outputs = target_->script_values().outputs();
     for (size_t i = 0; i < outputs.size(); i++) {
       OutputFile output_path(
           RemovePrefix(outputs[i].value(),
                        settings_->build_settings()->build_dir().value()));
       output_files.push_back(output_path);
       out_ << " ";
       path_output_.WriteFile(out_, output_path);
     }
     out_ << ": " << custom_rule_name << implicit_deps << std::endl;
+    if (target_->script_values().has_depfile()) {
+      out_ << "  depfile = ";
+      WriteDepfile(SourceFile());
+      out_ << std::endl;
+    }
   }
   out_ << std::endl;
 
   WriteStamp(output_files);
 }
 
 std::string NinjaScriptTargetWriter::WriteRuleDefinition(
     const FileTemplate& args_template) {
   // Make a unique name for this rule.
   //
@@ skipping 77 matching lines @@
     out_ << ": " << custom_rule_name << " ";
     path_output_.WriteFile(out_, sources[i]);
     out_ << implicit_deps << std::endl;
 
     // Windows needs a unique ID for the response file.
     if (target_->settings()->IsWin())
       out_ << "  unique_name = " << i << std::endl;
 
     if (args_template.has_substitutions())
       WriteArgsSubstitutions(sources[i], args_template);
+
+    if (target_->script_values().has_depfile()) {
+      out_ << "  depfile = ";
+      WriteDepfile(sources[i]);
+      out_ << std::endl;
+    }
   }
 }
 
 void NinjaScriptTargetWriter::WriteStamp(
     const std::vector<OutputFile>& output_files) {
   out_ << "build ";
   path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));
   out_ << ": "
        << helper_.GetRulePrefix(target_->settings()->toolchain())
        << "stamp";
   for (size_t i = 0; i < output_files.size(); i++) {
     out_ << " ";
     path_output_.WriteFile(out_, output_files[i]);
   }
   out_ << std::endl;
 }
 
 void NinjaScriptTargetWriter::WriteOutputFilesForBuildLine(
     const FileTemplate& output_template,
     const SourceFile& source,
     std::vector<OutputFile>* output_files) {
+  // If there is a depfile specified we need to list it as the first output as
+  // that is what ninja will expect the depfile to refer to itself as.
+  if (target_->script_values().has_depfile()) {
+    out_ << " ";
+    WriteDepfile(source);
+  }
   std::vector<std::string> output_template_result;
   output_template.ApplyString(source.value(), &output_template_result);
   for (size_t out_i = 0; out_i < output_template_result.size(); out_i++) {
     OutputFile output_path(output_template_result[out_i]);
     output_files->push_back(output_path);
     out_ << " ";
     path_output_.WriteFile(out_, output_path);
   }
 }
+
+void NinjaScriptTargetWriter::WriteDepfile(const SourceFile& source) {
+  std::vector<std::string> result;
+  GetDepfileTemplate().ApplyString(source.value(), &result);
+  path_output_.WriteFile(out_, OutputFile(result[0]));
+}
+
+FileTemplate NinjaScriptTargetWriter::GetDepfileTemplate() const {
+  std::vector<std::string> template_args;
+  std::string depfile_relative_to_build_dir =
+      RemovePrefix(target_->script_values().depfile().value(),
+                   settings_->build_settings()->build_dir().value());
+  template_args.push_back(depfile_relative_to_build_dir);
+  return FileTemplate(template_args);
+}