Reduce input dependencies in GN.

tools/gn/ninja_action_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_action_target_writer.h"
 
 #include "base/strings/string_util.h"
 #include "tools/gn/err.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/string_utils.h"
@@ skipping 22 matching lines @@
   std::vector<const Target*> extra_hard_deps;
   for (size_t i = 0; i < target_->deps().size(); i++)
     extra_hard_deps.push_back(target_->deps()[i].ptr);
 
   // For ACTIONs this is a bit inefficient since it creates an input dep
   // stamp file even though we're only going to use it once. It would save a
   // build step to skip this and write the order-only deps directly on the
   // build rule. This should probably be handled by WriteInputDepsStampAndGetDep
   // automatically if we supply a count of sources (so it can optimize based on
   // how many times things would be duplicated).
-  std::string implicit_deps = WriteInputDepsStampAndGetDep(extra_hard_deps);
+  OutputFile input_dep = WriteInputDepsStampAndGetDep(extra_hard_deps);
   out_ << std::endl;
 
   // Collects all output files for writing below.
   std::vector<OutputFile> output_files;
 
   if (target_->output_type() == Target::ACTION_FOREACH) {
     // Write separate build lines for each input source file.
-    WriteSourceRules(custom_rule_name, implicit_deps, &output_files);
+    WriteSourceRules(custom_rule_name, input_dep, &output_files);
   } else {
     DCHECK(target_->output_type() == Target::ACTION);
 
     // Write a rule that invokes the script once with the outputs as outputs,
     // and the data as inputs. It does not depend on the sources.
     out_ << "build";
     SubstitutionWriter::GetListAsOutputFiles(
         settings_, target_->action_values().outputs(), &output_files);
     path_output_.WriteFiles(out_, output_files);
 
-    out_ << ": " << custom_rule_name << implicit_deps << std::endl;
+    out_ << ": " << custom_rule_name;
+    if (!input_dep.value().empty()) {
+      // As in WriteSourceRules, we want to force this target to rebuild any
+      // time any of its dependencies change.
+      out_ << " | ";
+      path_output_.WriteFile(out_, input_dep);
+    }
+    out_ << std::endl;
     if (target_->action_values().has_depfile()) {
       out_ << "  depfile = ";
       WriteDepfile(SourceFile());
       out_ << std::endl;
     }
   }
   out_ << std::endl;
 
   // Write the stamp, which also depends on all datadeps. These are needed at
   // runtime and should be compiled when the action is, but don't need to be
@@ skipping 64 matching lines @@
     out_ << std::endl;
     out_ << "  description = ACTION " << target_label << std::endl;
     out_ << "  restat = 1" << std::endl;
   }
 
   return custom_rule_name;
 }
 
 void NinjaActionTargetWriter::WriteSourceRules(
     const std::string& custom_rule_name,
-    const std::string& implicit_deps,
+    const OutputFile& input_dep,
     std::vector<OutputFile>* output_files) {
   EscapeOptions args_escape_options;
   args_escape_options.mode = ESCAPE_NINJA_COMMAND;
   // We're writing the substitution values, these should not be quoted since
   // they will get pasted into the real command line.
   args_escape_options.inhibit_quoting = true;
 
   const std::vector<SubstitutionType>& args_substitutions_used =
       target_->action_values().args().required_types();
 
   const Target::FileList& sources = target_->sources();
   for (size_t i = 0; i < sources.size(); i++) {
     out_ << "build";
     WriteOutputFilesForBuildLine(sources[i], output_files);
 
     out_ << ": " << custom_rule_name << " ";
     path_output_.WriteFile(out_, sources[i]);
-    out_ << implicit_deps << std::endl;
+    if (!input_dep.value().empty()) {
+      // Using "|" for the dependencies forces all implicit dependencies to be
+      // fully up-to-date before running the action, and will re-run this
+      // action if any input dependencies change. This is important because
+      // this action may consume the outputs of previous steps.
+      out_ << " | ";
+      path_output_.WriteFile(out_, input_dep);
+    }
+    out_ << std::endl;
 
     // Windows needs a unique ID for the response file.
     if (target_->settings()->IsWin())
       out_ << "  unique_name = " << i << std::endl;
 
     SubstitutionWriter::WriteNinjaVariablesForSource(
         settings_, sources[i], args_substitutions_used,
         args_escape_options, out_);
 
     if (target_->action_values().has_depfile()) {
@@ skipping 16 matching lines @@
     out_ << " ";
     path_output_.WriteFile(out_, (*output_files)[i]);
   }
 }
 
 void NinjaActionTargetWriter::WriteDepfile(const SourceFile& source) {
   path_output_.WriteFile(out_,
       SubstitutionWriter::ApplyPatternToSourceAsOutputFile(
           settings_, target_->action_values().depfile(), source));
 }