GN: Complete static libs can't depend on static libs

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 "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 31 matching lines @@
   return Err(from->defined_from(), "Test-only dependency not allowed.",
       from->label().GetUserVisibleName(false) + "\n"
       "which is NOT marked testonly can't depend on\n" +
       to->label().GetUserVisibleName(false) + "\n"
       "which is marked testonly. Only targets with \"testonly = true\"\n"
       "can depend on other test-only targets.\n"
       "\n"
       "Either mark it test-only or don't do this dependency.");
 }
 
+Err MakeStaticLibDepsError(const Target* from, const Target* to) {
+  return Err(from->defined_from(),
+             "Complete static libraries can't depend on static libraries.",
+             from->label().GetUserVisibleName(false) +
+                 "\n"
+                 "which is a complete static library can't depend on\n" +
+                 to->label().GetUserVisibleName(false) +
+                 "\n"
+                 "which is a static library.\n"
+                 "\n"
+                 "Use source sets for intermediate targets instead.");
+}
+
 }  // 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),
       hard_dep_(false),
@@ skipping 57 matching lines @@
   PullDependentTargetInfo();
   PullForwardedDependentConfigs();
   PullRecursiveHardDeps();
 
   FillOutputFiles();
 
   if (!CheckVisibility(err))
     return false;
   if (!CheckTestonly(err))
     return false;
+  if (!CheckNoNestedStaticLibs(err))
+    return false;
 
   return true;
 }
 
 bool Target::IsLinkable() const {
   return output_type_ == STATIC_LIBRARY || output_type_ == SHARED_LIBRARY;
 }
 
 bool Target::IsFinal() const {
   return output_type_ == EXECUTABLE || output_type_ == SHARED_LIBRARY ||
@@ skipping 180 matching lines @@
 
 bool Target::CheckVisibility(Err* err) const {
   for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
     if (!Visibility::CheckItemVisibility(this, iter.target(), err))
       return false;
   }
   return true;
 }
 
 bool Target::CheckTestonly(Err* err) const {
-  // If there current target is marked testonly, it can include both testonly
+  // If the current target is marked testonly, it can include both testonly
   // and non-testonly targets, so there's nothing to check.
   if (testonly())
     return true;
 
   // Verify no deps have "testonly" set.
   for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
     if (iter.target()->testonly()) {
       *err = MakeTestOnlyError(this, iter.target());
       return false;
     }
   }
 
   return true;
 }
+
+bool Target::CheckNoNestedStaticLibs(Err* err) const {
+  // If the current target is not a complete static library, it can depend on
+  // static library targets with no problem.
+  if (!(output_type() == Target::STATIC_LIBRARY && complete_static_lib()))
+    return true;
+
+  // Verify no deps are static libraries.
+  for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
+    if (iter.target()->output_type() == Target::STATIC_LIBRARY) {
+      *err = MakeStaticLibDepsError(this, iter.target());
+      return false;
+    }
+  }
+
+  // Verify no inherited libraries are static libraries.
+  for (size_t i = 0; i < inherited_libraries().size(); ++i) {
+    if (inherited_libraries()[i]->output_type() == Target::STATIC_LIBRARY) {
+      *err = MakeStaticLibDepsError(this, inherited_libraries()[i]);
+      return false;
+    }
+  }
+  return true;
+}