Reduce input dependencies in GN.

tools/gn/ninja_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_target_writer.h"
 
 #include <fstream>
 #include <sstream>
 
 #include "base/file_util.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/ninja_action_target_writer.h"
 #include "tools/gn/ninja_binary_target_writer.h"
 #include "tools/gn/ninja_copy_target_writer.h"
 #include "tools/gn/ninja_group_target_writer.h"
 #include "tools/gn/ninja_utils.h"
+#include "tools/gn/output_file.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/string_utils.h"
 #include "tools/gn/substitution_writer.h"
 #include "tools/gn/target.h"
 #include "tools/gn/trace.h"
 
 NinjaTargetWriter::NinjaTargetWriter(const Target* target,
                                      std::ostream& out)
     : settings_(target->settings()),
       target_(target),
@@ skipping 106 matching lines @@
          << std::endl;
     written_anything = true;
   }
 
   // If we wrote any vars, separate them from the rest of the file that follows
   // with a blank line.
   if (written_anything)
     out_ << std::endl;
 }
 
-std::string NinjaTargetWriter::WriteInputDepsStampAndGetDep(
+OutputFile NinjaTargetWriter::WriteInputDepsStampAndGetDep(
     const std::vector<const Target*>& extra_hard_deps) const {
   CHECK(target_->toolchain())
       << "Toolchain not set on target "
       << target_->label().GetUserVisibleName(true);
 
   // For an action (where we run a script only once) the sources are the same
   // as the source prereqs.
   bool list_sources_as_input_deps = (target_->output_type() == Target::ACTION);
 
   // Actions get implicit dependencies on the script itself.
   bool add_script_source_as_dep =
       (target_->output_type() == Target::ACTION) ||
       (target_->output_type() == Target::ACTION_FOREACH);
 
   if (!add_script_source_as_dep &&
       extra_hard_deps.empty() &&
       target_->inputs().empty() &&
       target_->recursive_hard_deps().empty() &&
       (!list_sources_as_input_deps || target_->sources().empty()) &&
       target_->toolchain()->deps().empty())
-    return std::string();  // No input/hard deps.
+    return OutputFile();  // No input/hard deps.
 
   // One potential optimization is if there are few input dependencies (or
   // potentially few sources that depend on these) it's better to just write
   // all hard deps on each sources line than have this intermediate stamp. We
   // do the stamp file because duplicating all the order-only deps for each
   // source file can really explode the ninja file but this won't be the most
   // optimal thing in all cases.
 
   OutputFile input_stamp_file(
       RebaseSourceAbsolutePath(GetTargetOutputDir(target_).value(),
                                settings_->build_settings()->build_dir()));
   input_stamp_file.value().append(target_->label().name());
   input_stamp_file.value().append(".inputdeps.stamp");
 
-  std::ostringstream stamp_file_stream;
-  path_output_.WriteFile(stamp_file_stream, input_stamp_file);
-  std::string stamp_file_string = stamp_file_stream.str();
-
-  out_ << "build " << stamp_file_string << ": "
+  out_ << "build ";
+  path_output_.WriteFile(out_, input_stamp_file);
+  out_ << ": "
        << GetNinjaRulePrefixForToolchain(settings_)
        << Toolchain::ToolTypeToName(Toolchain::TYPE_STAMP);
 
   // Script file (if applicable).
   if (add_script_source_as_dep) {
     out_ << " ";
     path_output_.WriteFile(out_, target_->action_values().script());
   }
 
   // Input files are order-only deps.
@@ skipping 33 matching lines @@
     unique_deps.insert(toolchain_deps[i].ptr);
 
   for (std::set<const Target*>::const_iterator i = unique_deps.begin();
        i != unique_deps.end(); ++i) {
     DCHECK(!(*i)->dependency_output_file().value().empty());
     out_ << " ";
     path_output_.WriteFile(out_, (*i)->dependency_output_file());
   }
 
   out_ << "\n";
-  return " | " + stamp_file_string;
+  return input_stamp_file;
 }
 
 void NinjaTargetWriter::WriteStampForTarget(
     const std::vector<OutputFile>& files,
     const std::vector<OutputFile>& order_only_deps) {
   const OutputFile& stamp_file = target_->dependency_output_file();
 
   // First validate that the target's dependency is a stamp file. Otherwise,
   // we shouldn't have gotten here!
   CHECK(EndsWith(stamp_file.value(), ".stamp", false))
       << "Output should end in \".stamp\" for stamp file output. Instead got: "
       << "\"" << stamp_file.value() << "\"";
 
   out_ << "build ";
   path_output_.WriteFile(out_, stamp_file);
 
   out_ << ": "
        << GetNinjaRulePrefixForToolchain(settings_)
        << Toolchain::ToolTypeToName(Toolchain::TYPE_STAMP);
   path_output_.WriteFiles(out_, files);
 
   if (!order_only_deps.empty()) {
     out_ << " ||";
     path_output_.WriteFiles(out_, order_only_deps);
   }
   out_ << std::endl;
 }