Add an assert_no_deps variable to GN.

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 111 matching lines @@
     for (const auto& pair : target->private_deps()) {
       if (EnsureFileIsGeneratedByDependency(pair.ptr, file, false,
                                             consider_object_files,
                                             seen_targets))
         return true;  // Found a path.
     }
   }
   return false;
 }
 
+// check_this indicates if the given target should be matched against the
+// patterns. It should be set to false for the first call since assert_no_deps
+// shouldn't match the target itself.
+//
+// visited should point to an empty set, this will be used to prevent
+// multiple visits.
+//
+// *failure_path_str will be filled with a string describing the path of the
+// dependency failure, and failure_pattern will indicate the pattern in
+// assert_no that matched the target.
+//
+// Returns true if everything is OK. failure_path_str and failure_pattern_index
+// will be unchanged in this case.
+bool RecursiveCheckAssertNoDeps(const Target* target,
+                                bool check_this,
+                                const std::vector<LabelPattern>& assert_no,
+                                std::set<const Target*>* visited,
+                                std::string* failure_path_str,
+                                const LabelPattern** failure_pattern) {
+  static const char kIndentPath[] = "  ";
+
+  if (visited->find(target) != visited->end())
+    return true;  // Already checked this target.
+  visited->insert(target);
+
+  if (check_this) {
+    // Check this target against the given list of patterns.
+    for (const LabelPattern& pattern : assert_no) {
+      if (pattern.Matches(target->label())) {
+        // Found a match.
+        *failure_pattern = &pattern;
+        *failure_path_str =
+            kIndentPath + target->label().GetUserVisibleName(false);
+        return false;
+      }
+    }
+  }
+
+  // Recursively check dependencies.
+  for (const auto& pair : target->GetDeps(Target::DEPS_ALL)) {
+    if (pair.ptr->output_type() == Target::EXECUTABLE)
+      continue;
+    if (!RecursiveCheckAssertNoDeps(pair.ptr, true, assert_no, visited,
+                                    failure_path_str, failure_pattern)) {
+      // To reconstruct the path, prepend the current target to the error.
+      std::string prepend_path =
+          kIndentPath + target->label().GetUserVisibleName(false) + " ->\n";
+      failure_path_str->insert(0, prepend_path);
+      return false;
+    }
+  }
+
+  return true;
+}
+
 }  // namespace
 
 Target::Target(const Settings* settings, const Label& label)
     : Item(settings, label),
       output_type_(UNKNOWN),
       all_headers_public_(true),
       check_includes_(true),
       complete_static_lib_(false),
       testonly_(false),
       toolchain_(nullptr) {
@@ skipping 85 matching lines @@
 
   FillOutputFiles();
 
   if (settings()->build_settings()->check_for_bad_items()) {
     if (!CheckVisibility(err))
       return false;
     if (!CheckTestonly(err))
       return false;
     if (!CheckNoNestedStaticLibs(err))
       return false;
+    if (!CheckAssertNoDeps(err))
+      return false;
     CheckSourcesGenerated();
   }
 
   return true;
 }
 
 bool Target::IsBinary() const {
   return output_type_ == EXECUTABLE ||
          output_type_ == SHARED_LIBRARY ||
          output_type_ == LOADABLE_MODULE ||
@@ skipping 350 matching lines @@
   // Verify no inherited libraries are static libraries.
   for (const auto& lib : inherited_libraries().GetOrdered()) {
     if (lib->output_type() == Target::STATIC_LIBRARY) {
       *err = MakeStaticLibDepsError(this, lib);
       return false;
     }
   }
   return true;
 }
 
+bool Target::CheckAssertNoDeps(Err* err) const {
+  if (assert_no_deps_.empty())
+    return true;
+
+  std::set<const Target*> visited;
+  std::string failure_path_str;
+  const LabelPattern* failure_pattern = nullptr;
+
+  if (!RecursiveCheckAssertNoDeps(this, false, assert_no_deps_, &visited,
+                                  &failure_path_str, &failure_pattern)) {
+    *err = Err(defined_from(), "assert_no_deps failed.",
+        label().GetUserVisibleName(false) +
+        " has an assert_no_deps entry:\n  " +
+        failure_pattern->Describe() +
+        "\nwhich fails for the dependency path:\n" +
+        failure_path_str);
+    return false;
+  }
+  return true;
+}
+
 void Target::CheckSourcesGenerated() const {
   // Checks that any inputs or sources to this target that are in the build
   // directory are generated by a target that this one transitively depends on
   // in some way. We already guarantee that all generated files are written
   // to the build dir.
   //
   // See Scheduler::AddUnknownGeneratedInput's declaration for more.
   for (const SourceFile& file : sources_)
     CheckSourceGenerated(file);
   for (const SourceFile& file : inputs_)
@@ skipping 15 matching lines @@
   if (!EnsureFileIsGeneratedByDependency(this, out_file, true, false,
                                          &seen_targets)) {
     // Check object files (much slower and very rare) only if the "normal"
     // output check failed.
     seen_targets.clear();
     if (!EnsureFileIsGeneratedByDependency(this, out_file, true, true,
                                            &seen_targets))
       g_scheduler->AddUnknownGeneratedInput(this, source);
   }
 }