Stop propagation of dependent configs between toolchains.

tools/gn/target.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/target.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 334 matching lines @@
   // Copy public configs from all dependencies into the list of configs
   // applying to this target (configs_).
   PullDependentTargetConfigs();
 
   // Copies public dependencies' public configs to this target's public
   // configs. These configs have already been applied to this target by
   // PullDependentTargetConfigs above, along with the public configs from
   // private deps. This step re-exports them as public configs for targets that
   // depend on this one.
   for (const auto& dep : public_deps_) {
-    public_configs_.Append(dep.ptr->public_configs().begin(),
-                           dep.ptr->public_configs().end());
+    if (dep.ptr->toolchain() == toolchain()) {
+      public_configs_.Append(dep.ptr->public_configs().begin(),
+                             dep.ptr->public_configs().end());
+    }
   }
 
   // Copy our own libs and lib_dirs to the final set. This will be from our
   // target and all of our configs. We do this specially since these must be
   // inherited through the dependency tree (other flags don't work this way).
   //
   // This needs to happen after we pull dependent target configs for the
   // public config's libs to be included here. And it needs to happen
   // before pulling the dependent target libs so the libs are in the correct
   // order (local ones first, then the dependency's).
@@ skipping 128 matching lines @@
   if (!tool)
     return false;  // Tool does not apply for this toolchain.file.
 
   // Figure out what output(s) this compiler produces.
   SubstitutionWriter::ApplyListToCompilerAsOutputFile(
       this, source, tool->outputs(), outputs);
   return !outputs->empty();
 }
 
 void Target::PullDependentTargetConfigs() {
-  for (const auto& pair : GetDeps(DEPS_LINKED))
-    MergeAllDependentConfigsFrom(pair.ptr, &configs_, &all_dependent_configs_);
-  for (const auto& pair : GetDeps(DEPS_LINKED))
-    MergePublicConfigsFrom(pair.ptr, &configs_);
+  for (const auto& pair : GetDeps(DEPS_LINKED)) {
+    if (pair.ptr->toolchain() == toolchain()) {
+      MergeAllDependentConfigsFrom(pair.ptr, &configs_,
+                                   &all_dependent_configs_);
+    }
+  }
+  for (const auto& pair : GetDeps(DEPS_LINKED)) {
+    if (pair.ptr->toolchain() == toolchain()) {
+      MergePublicConfigsFrom(pair.ptr, &configs_);
+    }
+  }
 }
 
 void Target::PullDependentTargetLibsFrom(const Target* dep, bool is_public) {
   // Direct dependent libraries.
   if (dep->output_type() == STATIC_LIBRARY ||
       dep->output_type() == SHARED_LIBRARY ||
       dep->output_type() == SOURCE_SET)
     inherited_libraries_.Append(dep, is_public);
 
   if (dep->output_type() == SHARED_LIBRARY) {
@@ skipping 327 matching lines @@
     check_data_deps = g_scheduler->IsFileGeneratedByWriteRuntimeDeps(out_file);
     // Check object files (much slower and very rare) only if the "normal"
     // output check failed.
     consider_object_files = !check_data_deps;
     if (!EnsureFileIsGeneratedByDependency(this, out_file, true,
                                            consider_object_files,
                                            check_data_deps, &seen_targets))
       g_scheduler->AddUnknownGeneratedInput(this, source);
   }
 }