GN: Add notion of 'complete' static libraries, akin to GYP.

tools/gn/target_unittest.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 "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/config.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/target.h"
 #include "tools/gn/test_with_scope.h"
@@ skipping 256 matching lines @@
   EXPECT_TRUE(b_inherited.IndexOf(&c) != static_cast<size_t>(-1));
   EXPECT_TRUE(b_inherited.IndexOf(&d) != static_cast<size_t>(-1));
 
   // A should have B in its inherited libs, but not any others (the shared
   // library will include the static library and source set).
   const UniqueVector<const Target*>& a_inherited = a.inherited_libraries();
   EXPECT_EQ(1u, a_inherited.size());
   EXPECT_TRUE(a_inherited.IndexOf(&b) != static_cast<size_t>(-1));
 }
 
+TEST(Target, InheritCompleteStaticLib) {
+  TestWithScope setup;
+  Err err;
+
+  // Create a dependency chain:
+  //   A (executable) -> B (complete static lib) -> C (source set)
+  Target a(setup.settings(), Label(SourceDir("//foo/"), "a"));
+  a.set_output_type(Target::EXECUTABLE);
+  a.SetToolchain(setup.toolchain());
+  Target b(setup.settings(), Label(SourceDir("//foo/"), "b"));
+  b.set_output_type(Target::STATIC_LIBRARY);
+  b.set_complete_static_lib(true);
+  b.SetToolchain(setup.toolchain());
+  Target c(setup.settings(), Label(SourceDir("//foo/"), "c"));
+  c.set_output_type(Target::SOURCE_SET);
+  c.SetToolchain(setup.toolchain());
+  a.deps().push_back(LabelTargetPair(&b));
+  b.deps().push_back(LabelTargetPair(&c));
+
+  ASSERT_TRUE(c.OnResolved(&err));
+  ASSERT_TRUE(b.OnResolved(&err));
+  ASSERT_TRUE(a.OnResolved(&err));
+
+  // B should have C in its inherited libs.
+  const UniqueVector<const Target*>& b_inherited = b.inherited_libraries();
+  EXPECT_EQ(1u, b_inherited.size());
+  EXPECT_TRUE(b_inherited.IndexOf(&c) != static_cast<size_t>(-1));
+
+  // A should have B in its inherited libs, but not any others (the complete
+  // static library will include the source set).
+  const UniqueVector<const Target*>& a_inherited = a.inherited_libraries();
+  EXPECT_EQ(1u, a_inherited.size());
+  EXPECT_TRUE(a_inherited.IndexOf(&b) != static_cast<size_t>(-1));
+}
+
 TEST(Target, GetComputedOutputName) {
   TestWithScope setup;
   Err err;
 
   // Basic target with no prefix (executable type tool in the TestWithScope has
   // no prefix) or output name.
   Target basic(setup.settings(), Label(SourceDir("//foo/"), "bar"));
   basic.set_output_type(Target::EXECUTABLE);
   basic.SetToolchain(setup.toolchain());
   ASSERT_TRUE(basic.OnResolved(&err));
@@ skipping 108 matching lines @@
   ASSERT_TRUE(test.OnResolved(&err));
 
   // "product" is a non-test depending on testlib. This should fail.
   Target product(setup.settings(), Label(SourceDir("//app/"), "product"));
   product.set_testonly(false);
   product.set_output_type(Target::EXECUTABLE);
   product.deps().push_back(LabelTargetPair(&testlib));
   product.SetToolchain(setup.toolchain());
   ASSERT_FALSE(product.OnResolved(&err));
 }