GN: Refine 'complete' static library handling

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 37 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.");
-}
-
 // Set check_private_deps to true for the first invocation since a target
 // can see all of its dependencies. For recursive invocations this will be set
 // to false to follow only public dependency paths.
 //
 // Pass a pointer to an empty set for the first invocation. This will be used
 // to avoid duplicate checking.
 //
 // Checking of object files is optional because it is much slower. This allows
 // us to check targets for normal outputs, and then as a second pass check
 // object files (since we know it will be an error otherwise). This allows
@@ skipping 229 matching lines @@
   if (!ResolvePrecompiledHeaders(err))
     return false;
 
   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();
   }
 
   if (!write_runtime_deps_output_.value().empty())
     g_scheduler->AddWriteRuntimeDepsTarget(this);
 
   return true;
 }
@@ skipping 143 matching lines @@
     //
     // Static libraries and source sets aren't inherited across shared
     // library boundaries because they will be linked into the shared
     // library.
     inherited_libraries_.AppendPublicSharedLibraries(
         dep->inherited_libraries(), is_public);
   } else if (!dep->IsFinal()) {
     // The current target isn't linked, so propogate linked deps and
     // libraries up the dependency tree.
     inherited_libraries_.AppendInherited(dep->inherited_libraries(), is_public);
+  } else if (dep->complete_static_lib()) {
+    // Inherit only final targets through _complete_ static libraries.
+    //
+    // Inherited final libraries aren't linked into complete static libraries.
+    // They are forwarded here so that targets that depend on complete
+    // static libraries can link them in. Conversely, since complete static
+    // libraries link in non-final targets they shouldn't be inherited.
+    for (const auto& inherited :
+         dep->inherited_libraries().GetOrderedAndPublicFlag()) {
+      if (inherited.first->IsFinal()) {
+        inherited_libraries_.Append(inherited.first,
+                                    is_public && inherited.second);
+      }
+    }
+  }
 
-    // Inherited library settings.
+  // Library settings are always inherited across static library boundaries.
+  if (!dep->IsFinal() || dep->output_type() == STATIC_LIBRARY) {
     all_lib_dirs_.append(dep->all_lib_dirs());
     all_libs_.append(dep->all_libs());
   }
 }
 
 void Target::PullDependentTargetLibs() {
   for (const auto& dep : public_deps_)
     PullDependentTargetLibsFrom(dep.ptr, true);
   for (const auto& dep : private_deps_)
     PullDependentTargetLibsFrom(dep.ptr, false);
@@ skipping 198 matching lines @@
   for (const auto& pair : GetDeps(DEPS_ALL)) {
     if (pair.ptr->testonly()) {
       *err = MakeTestOnlyError(this, pair.ptr);
       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 (const auto& pair : GetDeps(DEPS_ALL)) {
-    if (pair.ptr->output_type() == Target::STATIC_LIBRARY) {
-      *err = MakeStaticLibDepsError(this, pair.ptr);
-      return false;
-    }
-  }
-
-  // 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)) {
@@ skipping 43 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);
   }
 }