Reduce input dependencies in GN.

tools/gn/ninja_binary_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_binary_target_writer.h"
 
 #include <set>
 
 #include "base/strings/string_util.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 109 matching lines @@
 #undef WRITE_FLAGS
 
   WriteSharedVars(subst);
 }
 
 void NinjaBinaryTargetWriter::WriteSources(
     std::vector<OutputFile>* object_files) {
   const Target::FileList& sources = target_->sources();
   object_files->reserve(sources.size());
 
-  std::string implicit_deps =
+  OutputFile input_dep =
       WriteInputDepsStampAndGetDep(std::vector<const Target*>());
 
   std::string rule_prefix = GetNinjaRulePrefixForToolchain(settings_);
 
   std::vector<OutputFile> tool_outputs;  // Prevent reallocation in loop.
   for (size_t i = 0; i < sources.size(); i++) {
     Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
     if (!GetOutputFilesForSource(target_, sources[i],
                                  &tool_type, &tool_outputs))
       continue;  // No output for this source.
 
     if (tool_type != Toolchain::TYPE_NONE) {
       out_ << "build";
       path_output_.WriteFiles(out_, tool_outputs);
       out_ << ": " << rule_prefix << Toolchain::ToolTypeToName(tool_type);
       out_ << " ";
       path_output_.WriteFile(out_, sources[i]);
-      out_ << implicit_deps << std::endl;
+      if (!input_dep.value().empty()) {
+        // Write out the input dependencies as an order-only dependency. This
+        // will cause Ninja to make sure the inputs are up-to-date before
+        // compiling this source, but changes in the inputs deps won't cause
+        // the file to be recompiled.
+        //
+        // This is important to prevent changes in unrelated actions that
+        // are upstream of this target from causing everything to be recompiled.
+        //
+        // Why can we get away with this rather than using implicit deps ("|",
+        // which will force rebuilds when the inputs change)?  For source code,
+        // the computed dependencies of all headers will be computed by the
+        // compiler, which will cause source rebuilds if any "real" upstream
+        // dependencies change.
+        //
+        // If a .cc file is generated by an input dependency, Ninja will see
+        // the input to the build rule doesn't exist, and that it is an output
+        // from a previous step, and build the previous step first.  This is a
+        // "real" dependency and doesn't need | or || to express.
+        //
+        // The only case where this rule matters is for the first build where
+        // no .d files exist, and Ninja doesn't know what that source file
+        // depends on. In this case it's sufficient to ensure that the upstream
+        // dependencies are built first. This is exactly what Ninja's order-
+        // only dependencies expresses.
+        out_ << " || ";
+        path_output_.WriteFile(out_, input_dep);
+      }
+      out_ << std::endl;
     }
 
     // It's theoretically possible for a compiler to produce more than one
     // output, but we'll only link to the first output.
     object_files->push_back(tool_outputs[0]);
   }
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteLinkerStuff(
@@ skipping 49 matching lines @@
     }
   }
 
   // Append implicit dependencies collected above.
   if (!implicit_deps.empty()) {
     out_ << " |";
     path_output_.WriteFiles(out_, implicit_deps);
   }
 
   // Append data dependencies as order-only dependencies.
+  //
+  // This will include data dependencies and input dependencies (like when
+  // this target depends on an action). Having the data dependencies in this
+  // list ensures that the data is available at runtime when the user builds
+  // this target.
+  //
+  // The action dependencies are not strictly necessary in this case. They
+  // should also have been collected via the input deps stamp that each source
+  // file has for an order-only dependency, and since this target depends on
+  // the sources, there is already an implicit order-only dependency. However,
+  // it's extra work to separate these out and there's no disadvantage to
+  // listing them again.
   WriteOrderOnlyDependencies(non_linkable_deps);
 
   // End of the link "build" line.
   out_ << std::endl;
 
   // These go in the inner scope of the link line.
   WriteLinkerFlags();
   WriteLibs();
   WriteOutputExtension();
   WriteSolibs(solibs);
@@ skipping 201 matching lines @@
     return false;  // No tool for this file (it's a header file or something).
   const Tool* tool = target->toolchain()->GetTool(*computed_tool_type);
   if (!tool)
     return false;  // Tool does not apply for this toolchain.file.
 
   // Figure out what output(s) this compiler produces.
   SubstitutionWriter::ApplyListToCompilerAsOutputFile(
       target, source, tool->outputs(), outputs);
   return !outputs->empty();
 }