Allow dependencies of toolchains 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"
@@ skipping 68 matching lines @@
 
   std::string contents = file.str();
   base::WriteFile(ninja_file, contents.c_str(),
                   static_cast<int>(contents.size()));
 }
 
 std::string NinjaTargetWriter::WriteInputDepsStampAndGetDep(
     const std::vector<const Target*>& extra_hard_deps) const {
   // 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;
+  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;
+  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()))
+      (!list_sources_as_input_deps || target_->sources().empty()) &&
+      toolchain_->deps().empty())
     return std::string();  // 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 = helper_.GetTargetOutputDir(target_);
@@ skipping 28 matching lines @@
   }
 
   // Add on any hard deps that are direct or indirect dependencies.
   const std::set<const Target*>& hard_deps = target_->recursive_hard_deps();
   for (std::set<const Target*>::const_iterator i = hard_deps.begin();
        i != hard_deps.end(); ++i) {
     out_ << " ";
     path_output_.WriteFile(out_, helper_.GetTargetOutputFile(*i));
   }
 
+  // Toolchain dependencies. These must be resolved before doing anything.
+  // This just writs all toolchain deps for simplicity. If we find that
+  // toolchains often have more than one dependency, we could consider writing
+  // a toolchain-specific stamp file and only include the stamp here.
+  const LabelTargetVector& toolchain_deps = toolchain_->deps();
+  for (size_t i = 0; i < toolchain_deps.size(); i++) {
+    out_ << " ";
+    path_output_.WriteFile(out_,
+                           helper_.GetTargetOutputFile(toolchain_deps[i].ptr));
+  }
+
   // Extra hard deps passed in.
   for (size_t i = 0; i < extra_hard_deps.size(); i++) {
     out_ << " ";
     path_output_.WriteFile(out_,
         helper_.GetTargetOutputFile(extra_hard_deps[i]));
   }
 
   out_ << "\n";
   return " | " + stamp_file_string;
 }
 
 FileTemplate NinjaTargetWriter::GetOutputTemplate() const {
   const Target::FileList& outputs = target_->action_values().outputs();
   std::vector<std::string> output_template_args;
   for (size_t i = 0; i < outputs.size(); i++) {
     // All outputs should be in the output dir.
     output_template_args.push_back(
         RemovePrefix(outputs[i].value(),
                      settings_->build_settings()->build_dir().value()));
   }
   return FileTemplate(target_->settings(), output_template_args);
 }