Allow dependencies of toolchains in GN.

tools/gn/builder.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/builder.h"
 
 #include "tools/gn/config.h"
 #include "tools/gn/err.h"
 #include "tools/gn/loader.h"
 #include "tools/gn/scheduler.h"
@@ skipping 73 matching lines @@
     g_scheduler->FailWithError(err);
     return;
   }
 
   record->set_item(item.Pass());
 
   // Do target-specific dependency setup. This will also schedule dependency
   // loads for targets that are required.
   switch (type) {
     case BuilderRecord::ITEM_TARGET:
-      if (!TargetDefined(record, &err)) {
-        g_scheduler->FailWithError(err);
-        return;
-      }
+      TargetDefined(record, &err);
       break;
     case BuilderRecord::ITEM_TOOLCHAIN:
-      loader_->ToolchainLoaded(record->item()->AsToolchain());
+      ToolchainDefined(record, &err);
       break;
     default:
       break;
   }
+  if (err.has_error()) {
+    g_scheduler->FailWithError(err);
+    return;
+  }
 
   if (record->can_resolve()) {
     if (!ResolveItem(record, &err)) {
       g_scheduler->FailWithError(err);
       return;
     }
   }
 }
 
 const Item* Builder::GetItem(const Label& label) const {
@@ skipping 121 matching lines @@
   // All targets in the default toolchain get generated by default. We also
   // check if this target was previously marked as "required" and force setting
   // the bit again so the target's dependencies (which we now know) get the
   // required bit pushed to them.
   if (record->should_generate() || target->settings()->is_default())
     RecursiveSetShouldGenerate(record, true);
 
   return true;
 }
 
+bool Builder::ToolchainDefined(BuilderRecord* record, Err* err) {
+  Toolchain* toolchain = record->item()->AsToolchain();
+
+  if (!AddDeps(record, toolchain->deps(), err))
+    return false;
+
+  // The default toolchain gets generated by default. Also propogate the
+  // generate flag if it depends on items in a non-default toolchain.
+  if (record->should_generate() ||
+      toolchain->settings()->default_toolchain_label() == toolchain->label())
+    RecursiveSetShouldGenerate(record, true);
+
+  loader_->ToolchainLoaded(toolchain);
+  return true;
+}
+
 BuilderRecord* Builder::GetOrCreateRecordOfType(const Label& label,
                                                 const ParseNode* request_from,
                                                 BuilderRecord::ItemType type,
                                                 Err* err) {
   BuilderRecord* record = GetRecord(label);
   if (!record) {
     // Not seen this record yet, create a new one.
     record = new BuilderRecord(type, label);
     record->set_originally_referenced_from(request_from);
     records_[label] = record;
@@ skipping 117 matching lines @@
 
   if (record->type() == BuilderRecord::ITEM_TARGET) {
     Target* target = record->item()->AsTarget();
     if (!ResolveDeps(&target->deps(), err) ||
         !ResolveDeps(&target->datadeps(), err) ||
         !ResolveConfigs(&target->configs(), err) ||
         !ResolveConfigs(&target->all_dependent_configs(), err) ||
         !ResolveConfigs(&target->direct_dependent_configs(), err) ||
         !ResolveForwardDependentConfigs(target, err))
       return false;
+  } else if (record->type() == BuilderRecord::ITEM_TOOLCHAIN) {
+    Toolchain* toolchain = record->item()->AsToolchain();
+    if (!ResolveDeps(&toolchain->deps(), err))
+      return false;
   }
 
   record->set_resolved(true);
   record->item()->OnResolved();
   if (!resolved_callback_.is_null())
     resolved_callback_.Run(record);
 
   // Recursively update everybody waiting on this item to be resolved.
   BuilderRecordSet& waiting_set = record->waiting_on_resolution();
   for (BuilderRecordSet::iterator i = waiting_set.begin();
@@ skipping 77 matching lines @@
   // Walk backwards since the dependency arrows point in the reverse direction.
   std::string ret;
   for (int i = static_cast<int>(cycle.size()) - 1; i >= 0; i--) {
     ret += "  " + cycle[i]->label().GetUserVisibleName(false);
     if (i != 0)
       ret += " ->\n";
   }
 
   return ret;
 }