diff --git a/src/gn/ninja_binary_target_writer.cc b/src/gn/ninja_binary_target_writer.cc
index b1dbbef..5fb8929 100644
--- a/src/gn/ninja_binary_target_writer.cc
+++ b/src/gn/ninja_binary_target_writer.cc
@@ -137,8 +137,8 @@
   }
 
   // Inherited libraries.
-  for (auto* inherited_target : target_->inherited_libraries().GetOrdered()) {
-    ClassifyDependency(inherited_target, &classified_deps);
+  for (const auto& inherited : resolved().GetInheritedLibraries(target_)) {
+    ClassifyDependency(inherited.target(), &classified_deps);
   }
 
   // Data deps.
diff --git a/src/gn/ninja_c_binary_target_writer.cc b/src/gn/ninja_c_binary_target_writer.cc
index f74d208..9978b63 100644
--- a/src/gn/ninja_c_binary_target_writer.cc
+++ b/src/gn/ninja_c_binary_target_writer.cc
@@ -668,7 +668,8 @@
   // rlibs only depended on inside a shared library dependency).
   std::vector<OutputFile> transitive_rustlibs;
   if (target_->IsFinal()) {
-    for (const auto* dep : target_->inherited_libraries().GetOrdered()) {
+    for (const auto& inherited : resolved().GetInheritedLibraries(target_)) {
+      const Target* dep = inherited.target();
       if (dep->output_type() == Target::RUST_LIBRARY) {
         transitive_rustlibs.push_back(dep->dependency_output_file());
         implicit_deps.push_back(dep->dependency_output_file());
diff --git a/src/gn/resolved_target_data.cc b/src/gn/resolved_target_data.cc
index 467e2fb..d944123 100644
--- a/src/gn/resolved_target_data.cc
+++ b/src/gn/resolved_target_data.cc
@@ -88,3 +88,86 @@
   info->hard_deps = std::move(all_hard_deps);
   info->has_hard_deps = true;
 }
+
+void ResolvedTargetData::ComputeInheritedLibs(TargetInfo* info) const {
+  TargetPublicPairListBuilder inherited_libraries;
+
+  ComputeInheritedLibsFor(info->deps.public_deps(), true, &inherited_libraries);
+  ComputeInheritedLibsFor(info->deps.private_deps(), false,
+                          &inherited_libraries);
+
+  info->inherited_libs = inherited_libraries.Build();
+  info->has_inherited_libs = true;
+}
+
+void ResolvedTargetData::ComputeInheritedLibsFor(
+    base::span<const Target*> deps,
+    bool is_public,
+    TargetPublicPairListBuilder* inherited_libraries) const {
+  for (const Target* dep : deps) {
+    // Direct dependent libraries.
+    if (dep->output_type() == Target::STATIC_LIBRARY ||
+        dep->output_type() == Target::SHARED_LIBRARY ||
+        dep->output_type() == Target::RUST_LIBRARY ||
+        dep->output_type() == Target::SOURCE_SET ||
+        (dep->output_type() == Target::CREATE_BUNDLE &&
+         dep->bundle_data().is_framework())) {
+      inherited_libraries->Append(dep, is_public);
+    }
+    if (dep->output_type() == Target::SHARED_LIBRARY) {
+      // Shared library dependendencies are inherited across public shared
+      // library boundaries.
+      //
+      // In this case:
+      //   EXE -> INTERMEDIATE_SHLIB --[public]--> FINAL_SHLIB
+      // The EXE will also link to to FINAL_SHLIB. The public dependency means
+      // that the EXE can use the headers in FINAL_SHLIB so the FINAL_SHLIB
+      // will need to appear on EXE's link line.
+      //
+      // However, if the dependency is private:
+      //   EXE -> INTERMEDIATE_SHLIB --[private]--> FINAL_SHLIB
+      // the dependency will not be propagated because INTERMEDIATE_SHLIB is
+      // not granting permission to call functions from FINAL_SHLIB. If EXE
+      // wants to use functions (and link to) FINAL_SHLIB, it will need to do
+      // so explicitly.
+      //
+      // Static libraries and source sets aren't inherited across shared
+      // library boundaries because they will be linked into the shared
+      // library. Rust dylib deps are handled above and transitive deps are
+      // resolved by the compiler.
+      const TargetInfo* dep_info = GetTargetInheritedLibs(dep);
+      for (const auto& pair : dep_info->inherited_libs) {
+        if (pair.target()->output_type() == Target::SHARED_LIBRARY &&
+            pair.is_public()) {
+          inherited_libraries->Append(pair.target(), is_public);
+        }
+      }
+    } else if (!dep->IsFinal()) {
+      // The current target isn't linked, so propagate linked deps and
+      // libraries up the dependency tree.
+      const TargetInfo* dep_info = GetTargetInheritedLibs(dep);
+      for (const auto& pair : dep_info->inherited_libs) {
+        // Proc macros are not linked into targets that depend on them, so do
+        // not get inherited; they are consumed by the Rust compiler and only
+        // need to be specified in --extern.
+        if (pair.target()->output_type() != Target::RUST_PROC_MACRO)
+          inherited_libraries->Append(pair.target(),
+                                      is_public && pair.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.
+      const TargetInfo* dep_info = GetTargetInheritedLibs(dep);
+      for (const auto& pair : dep_info->inherited_libs) {
+        if (pair.target()->IsFinal())
+          inherited_libraries->Append(pair.target(),
+                                      is_public && pair.is_public());
+      }
+    }
+  }
+}
diff --git a/src/gn/resolved_target_data.h b/src/gn/resolved_target_data.h
index bc992a1..0dc36be 100644
--- a/src/gn/resolved_target_data.h
+++ b/src/gn/resolved_target_data.h
@@ -103,6 +103,13 @@
     return GetTargetHardDeps(target)->hard_deps;
   }
 
+  // Retrieves an ordered list of (target, is_public) pairs for all link-time
+  // libraries inherited by this target.
+  const std::vector<TargetPublicPair>& GetInheritedLibraries(
+      const Target* target) const {
+    return GetTargetInheritedLibs(target)->inherited_libs;
+  }
+
  private:
   // The information associated with a given Target pointer.
   struct TargetInfo {
@@ -120,6 +127,7 @@
     bool has_lib_info = false;
     bool has_framework_info = false;
     bool has_hard_deps = false;
+    bool has_inherited_libs = false;
 
     // Only valid if |has_lib_info| is true.
     std::vector<SourceDir> lib_dirs;
@@ -132,6 +140,9 @@
 
     // Only valid if |has_hard_deps| is true.
     TargetSet hard_deps;
+
+    // Only valid if |has_inherited_libs| is true.
+    std::vector<TargetPublicPair> inherited_libs;
   };
 
   // Retrieve TargetInfo value associated with |target|. Create
@@ -165,12 +176,28 @@
     return info;
   }
 
+  const TargetInfo* GetTargetInheritedLibs(const Target* target) const {
+    TargetInfo* info = GetTargetInfo(target);
+    if (!info->has_inherited_libs) {
+      ComputeInheritedLibs(info);
+      DCHECK(info->has_inherited_libs);
+    }
+    return info;
+  }
+
   // Compute the portion of TargetInfo guarded by one of the |has_xxx|
   // booleans. This performs recursive and expensive computations and
   // should only be called once per TargetInfo instance.
   void ComputeLibInfo(TargetInfo* info) const;
   void ComputeFrameworkInfo(TargetInfo* info) const;
   void ComputeHardDeps(TargetInfo* info) const;
+  void ComputeInheritedLibs(TargetInfo* info) const;
+
+  // Helper function usde by ComputeInheritedLibs().
+  void ComputeInheritedLibsFor(
+      base::span<const Target*> deps,
+      bool is_public,
+      TargetPublicPairListBuilder* inherited_libraries) const;
 
   // A { Target* -> TargetInfo } map that will create entries
   // on demand (hence the mutable qualifier). Implemented with a
diff --git a/src/gn/resolved_target_data_unittest.cc b/src/gn/resolved_target_data_unittest.cc
index 5871d39..d4f60b4 100644
--- a/src/gn/resolved_target_data_unittest.cc
+++ b/src/gn/resolved_target_data_unittest.cc
@@ -167,3 +167,244 @@
   const auto& framework_dirs3 = resolved.GetLinkedFrameworkDirs(&exec);
   EXPECT_EQ(0u, framework_dirs3.size());
 }
+
+TEST(ResolvedTargetDataTest, InheritLibs) {
+  TestWithScope setup;
+  Err err;
+
+  // Create a dependency chain:
+  //   A (executable) -> B (shared lib) -> C (static lib) -> D (source set)
+  TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
+  TestTarget b(setup, "//foo:b", Target::SHARED_LIBRARY);
+  TestTarget c(setup, "//foo:c", Target::STATIC_LIBRARY);
+  TestTarget d(setup, "//foo:d", Target::SOURCE_SET);
+  a.private_deps().push_back(LabelTargetPair(&b));
+  b.private_deps().push_back(LabelTargetPair(&c));
+  c.private_deps().push_back(LabelTargetPair(&d));
+
+  ASSERT_TRUE(d.OnResolved(&err));
+  ASSERT_TRUE(c.OnResolved(&err));
+  ASSERT_TRUE(b.OnResolved(&err));
+  ASSERT_TRUE(a.OnResolved(&err));
+
+  ResolvedTargetData resolved;
+
+  // C should have D in its inherited libs.
+  const auto& c_inherited_libs = resolved.GetInheritedLibraries(&c);
+  ASSERT_EQ(1u, c_inherited_libs.size());
+  EXPECT_EQ(&d, c_inherited_libs[0].target());
+
+  // B should have C and D in its inherited libs.
+  const auto& b_inherited = resolved.GetInheritedLibraries(&b);
+  ASSERT_EQ(2u, b_inherited.size());
+  EXPECT_EQ(&c, b_inherited[0].target());
+  EXPECT_EQ(&d, b_inherited[1].target());
+
+  // A should have B in its inherited libs, but not any others (the shared
+  // library will include the static library and source set).
+  const auto& a_inherited = resolved.GetInheritedLibraries(&a);
+  ASSERT_EQ(1u, a_inherited.size());
+  EXPECT_EQ(&b, a_inherited[0].target());
+}
+
+TEST(ResolvedTargetData, NoActionDepPropgation) {
+  TestWithScope setup;
+  Err err;
+  ResolvedTargetData resolved;
+  // Create a dependency chain:
+  //   A (exe) -> B (action) -> C (source_set)
+  {
+    TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
+    TestTarget b(setup, "//foo:b", Target::ACTION);
+    TestTarget c(setup, "//foo:c", Target::SOURCE_SET);
+
+    a.private_deps().push_back(LabelTargetPair(&b));
+    b.private_deps().push_back(LabelTargetPair(&c));
+
+    ASSERT_TRUE(c.OnResolved(&err));
+    ASSERT_TRUE(b.OnResolved(&err));
+    ASSERT_TRUE(a.OnResolved(&err));
+
+    // The executable should not have inherited the source set across the
+    // action.
+    ASSERT_TRUE(resolved.GetInheritedLibraries(&a).empty());
+  }
+}
+
+TEST(ResolvedTargetDataTest, InheritCompleteStaticLib) {
+  TestWithScope setup;
+  Err err;
+
+  ResolvedTargetData resolved;
+
+  // Create a dependency chain:
+  //   A (executable) -> B (complete static lib) -> C (source set)
+  TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
+  TestTarget b(setup, "//foo:b", Target::STATIC_LIBRARY);
+  b.set_complete_static_lib(true);
+
+  const LibFile lib("foo");
+  const SourceDir lib_dir("/foo_dir/");
+  TestTarget c(setup, "//foo:c", Target::SOURCE_SET);
+  c.config_values().libs().push_back(lib);
+  c.config_values().lib_dirs().push_back(lib_dir);
+
+  a.public_deps().push_back(LabelTargetPair(&b));
+  b.public_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 auto& b_inherited = resolved.GetInheritedLibraries(&b);
+  ASSERT_EQ(1u, b_inherited.size());
+  EXPECT_EQ(&c, b_inherited[0].target());
+
+  // A should have B in its inherited libs, but not any others (the complete
+  // static library will include the source set).
+  const auto& a_inherited = resolved.GetInheritedLibraries(&a);
+  ASSERT_EQ(1u, a_inherited.size());
+  EXPECT_EQ(&b, a_inherited[0].target());
+
+  // A should inherit the libs and lib_dirs from the C.
+  const auto& a_libs = resolved.GetLinkedLibraries(&a);
+  ASSERT_EQ(1u, a_libs.size());
+  EXPECT_EQ(lib, a_libs[0]);
+
+  const auto& a_lib_dirs = resolved.GetLinkedLibraryDirs(&a);
+  ASSERT_EQ(1u, a_lib_dirs.size());
+  EXPECT_EQ(lib_dir, a_lib_dirs[0]);
+}
+
+TEST(ResolvedTargetDataTest, InheritCompleteStaticLibStaticLibDeps) {
+  TestWithScope setup;
+  Err err;
+
+  // Create a dependency chain:
+  //   A (executable) -> B (complete static lib) -> C (static lib)
+  TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
+  TestTarget b(setup, "//foo:b", Target::STATIC_LIBRARY);
+  b.set_complete_static_lib(true);
+  TestTarget c(setup, "//foo:c", Target::STATIC_LIBRARY);
+  a.public_deps().push_back(LabelTargetPair(&b));
+  b.public_deps().push_back(LabelTargetPair(&c));
+
+  ASSERT_TRUE(c.OnResolved(&err));
+  ASSERT_TRUE(b.OnResolved(&err));
+  ASSERT_TRUE(a.OnResolved(&err));
+
+  ResolvedTargetData resolved;
+
+  // B should have C in its inherited libs.
+  const auto& b_inherited = resolved.GetInheritedLibraries(&b);
+  ASSERT_EQ(1u, b_inherited.size());
+  EXPECT_EQ(&c, b_inherited[0].target());
+
+  // A should have B in its inherited libs, but not any others (the complete
+  // static library will include the static library).
+  const auto& a_inherited = resolved.GetInheritedLibraries(&a);
+  ASSERT_EQ(1u, a_inherited.size());
+  EXPECT_EQ(&b, a_inherited[0].target());
+}
+
+TEST(ResolvedTargetDataTest,
+     InheritCompleteStaticLibInheritedCompleteStaticLibDeps) {
+  TestWithScope setup;
+  Err err;
+
+  // Create a dependency chain:
+  //   A (executable) -> B (complete static lib) -> C (complete static lib)
+  TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
+  TestTarget b(setup, "//foo:b", Target::STATIC_LIBRARY);
+  b.set_complete_static_lib(true);
+  TestTarget c(setup, "//foo:c", Target::STATIC_LIBRARY);
+  c.set_complete_static_lib(true);
+
+  a.private_deps().push_back(LabelTargetPair(&b));
+  b.private_deps().push_back(LabelTargetPair(&c));
+
+  ASSERT_TRUE(c.OnResolved(&err));
+  ASSERT_TRUE(b.OnResolved(&err));
+  ASSERT_TRUE(a.OnResolved(&err));
+
+  ResolvedTargetData resolved;
+
+  // B should have C in its inherited libs.
+  const auto& b_inherited = resolved.GetInheritedLibraries(&b);
+  ASSERT_EQ(1u, b_inherited.size());
+  EXPECT_EQ(&c, b_inherited[0].target());
+
+  // A should have B and C in its inherited libs.
+  const auto& a_inherited = resolved.GetInheritedLibraries(&a);
+  ASSERT_EQ(2u, a_inherited.size());
+  EXPECT_EQ(&b, a_inherited[0].target());
+  EXPECT_EQ(&c, a_inherited[1].target());
+}
+
+TEST(ResolvedTargetDataTest, NoActionDepPropgation) {
+  TestWithScope setup;
+  Err err;
+  ResolvedTargetData resolved;
+
+  // Create a dependency chain:
+  //   A (exe) -> B (action) -> C (source_set)
+  {
+    TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
+    TestTarget b(setup, "//foo:b", Target::ACTION);
+    TestTarget c(setup, "//foo:c", Target::SOURCE_SET);
+
+    a.private_deps().push_back(LabelTargetPair(&b));
+    b.private_deps().push_back(LabelTargetPair(&c));
+
+    ASSERT_TRUE(c.OnResolved(&err));
+    ASSERT_TRUE(b.OnResolved(&err));
+    ASSERT_TRUE(a.OnResolved(&err));
+
+    // The executable should not have inherited the source set across the
+    // action.
+    const auto& libs = resolved.GetInheritedLibraries(&a);
+    ASSERT_TRUE(libs.empty());
+  }
+}
+
+// Shared libraries should be inherited across public shared library
+// boundaries.
+TEST(ResolvedTargetDataTest, SharedInheritance) {
+  TestWithScope setup;
+  Err err;
+
+  // Create two leaf shared libraries.
+  TestTarget pub(setup, "//foo:pub", Target::SHARED_LIBRARY);
+  ASSERT_TRUE(pub.OnResolved(&err));
+
+  TestTarget priv(setup, "//foo:priv", Target::SHARED_LIBRARY);
+  ASSERT_TRUE(priv.OnResolved(&err));
+
+  // Intermediate shared library with the leaf shared libraries as
+  // dependencies, one public, one private.
+  TestTarget inter(setup, "//foo:inter", Target::SHARED_LIBRARY);
+  inter.public_deps().push_back(LabelTargetPair(&pub));
+  inter.private_deps().push_back(LabelTargetPair(&priv));
+  ASSERT_TRUE(inter.OnResolved(&err));
+
+  // The intermediate shared library should have both "pub" and "priv" in its
+  // inherited libraries.
+  ResolvedTargetData resolved;
+  const auto& inter_inherited = resolved.GetInheritedLibraries(&inter);
+  ASSERT_EQ(2u, inter_inherited.size());
+  EXPECT_EQ(&pub, inter_inherited[0].target());
+  EXPECT_EQ(&priv, inter_inherited[1].target());
+
+  // Make a toplevel executable target depending on the intermediate one.
+  TestTarget exe(setup, "//foo:exe", Target::SHARED_LIBRARY);
+  exe.private_deps().push_back(LabelTargetPair(&inter));
+  ASSERT_TRUE(exe.OnResolved(&err));
+
+  // The exe's inherited libraries should be "inter" (because it depended
+  // directly on it) and "pub" (because inter depended publicly on it).
+  const auto& exe_inherited = resolved.GetInheritedLibraries(&exe);
+  ASSERT_EQ(2u, exe_inherited.size());
+  EXPECT_EQ(&inter, exe_inherited[0].target());
+  EXPECT_EQ(&pub, exe_inherited[1].target());
+}
diff --git a/src/gn/target.cc b/src/gn/target.cc
index 84cfbfa..5bdfdef 100644
--- a/src/gn/target.cc
+++ b/src/gn/target.cc
@@ -739,16 +739,6 @@
 }
 
 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() == RUST_LIBRARY ||
-      dep->output_type() == SOURCE_SET ||
-      (dep->output_type() == CREATE_BUNDLE &&
-       dep->bundle_data().is_framework())) {
-    inherited_libraries_.Append(dep, is_public);
-  }
-
   // Collect Rust libraries that are accessible from the current target, or
   // transitively part of the current target.
   if (dep->output_type() == STATIC_LIBRARY ||
@@ -780,64 +770,6 @@
     rust_transitive_inherited_libs_.Append(dep, true);
     rust_transitive_inheritable_libs_.Append(dep, is_public);
   }
-
-  if (dep->output_type() == SHARED_LIBRARY) {
-    // Shared library dependendencies are inherited across public shared
-    // library boundaries.
-    //
-    // In this case:
-    //   EXE -> INTERMEDIATE_SHLIB --[public]--> FINAL_SHLIB
-    // The EXE will also link to to FINAL_SHLIB. The public dependency means
-    // that the EXE can use the headers in FINAL_SHLIB so the FINAL_SHLIB
-    // will need to appear on EXE's link line.
-    //
-    // However, if the dependency is private:
-    //   EXE -> INTERMEDIATE_SHLIB --[private]--> FINAL_SHLIB
-    // the dependency will not be propagated because INTERMEDIATE_SHLIB is
-    // not granting permission to call functions from FINAL_SHLIB. If EXE
-    // wants to use functions (and link to) FINAL_SHLIB, it will need to do
-    // so explicitly.
-    //
-    // Static libraries and source sets aren't inherited across shared
-    // library boundaries because they will be linked into the shared
-    // library. Rust dylib deps are handled above and transitive deps are
-    // resolved by the compiler.
-    inherited_libraries_.AppendPublicSharedLibraries(dep->inherited_libraries(),
-                                                     is_public);
-  } else {
-    InheritedLibraries transitive;
-
-    if (!dep->IsFinal()) {
-      // The current target isn't linked, so propagate linked deps and
-      // libraries up the dependency tree.
-      for (const auto& [inherited, inherited_is_public] :
-           dep->inherited_libraries().GetOrderedAndPublicFlag()) {
-        transitive.Append(inherited, is_public && inherited_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, inherited_is_public] :
-           dep->inherited_libraries().GetOrderedAndPublicFlag()) {
-        if (inherited->IsFinal()) {
-          transitive.Append(inherited, is_public && inherited_is_public);
-        }
-      }
-    }
-
-    for (const auto& [target, pub] : transitive.GetOrderedAndPublicFlag()) {
-      // Proc macros are not linked into targets that depend on them, so do not
-      // get inherited; they are consumed by the Rust compiler and only need to
-      // be specified in --extern.
-      if (target->output_type() != RUST_PROC_MACRO) {
-        inherited_libraries_.Append(target, pub);
-      }
-    }
-  }
 }
 
 void Target::PullDependentTargetLibs() {
diff --git a/src/gn/target.h b/src/gn/target.h
index d672985..348f49f 100644
--- a/src/gn/target.h
+++ b/src/gn/target.h
@@ -14,7 +14,6 @@
 #include "gn/action_values.h"
 #include "gn/bundle_data.h"
 #include "gn/config_values.h"
-#include "gn/inherited_libraries.h"
 #include "gn/item.h"
 #include "gn/label_pattern.h"
 #include "gn/label_ptr.h"
@@ -298,10 +297,6 @@
   const LabelPtrPair<Pool>& pool() const { return pool_; }
   void set_pool(LabelPtrPair<Pool> pool) { pool_ = std::move(pool); }
 
-  const InheritedLibraries& inherited_libraries() const {
-    return inherited_libraries_;
-  }
-
   // This config represents the configuration set directly on this target.
   ConfigValues& config_values();
   const ConfigValues& config_values() const;
@@ -485,10 +480,6 @@
 
   LabelPtrPair<Pool> pool_;
 
-  // Static libraries, shared libraries, and source sets from transitive deps
-  // that need to be linked.
-  InheritedLibraries inherited_libraries_;
-
   std::vector<LabelPattern> friends_;
   std::vector<LabelPattern> assert_no_deps_;
 
diff --git a/src/gn/target_unittest.cc b/src/gn/target_unittest.cc
index 6031fed..d6554fd 100644
--- a/src/gn/target_unittest.cc
+++ b/src/gn/target_unittest.cc
@@ -203,173 +203,6 @@
   EXPECT_EQ(&all_dependent, a.all_dependent_configs()[0].ptr);
 }
 
-TEST_F(TargetTest, InheritLibs) {
-  TestWithScope setup;
-  Err err;
-
-  // Create a dependency chain:
-  //   A (executable) -> B (shared lib) -> C (static lib) -> D (source set)
-  TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
-  TestTarget b(setup, "//foo:b", Target::SHARED_LIBRARY);
-  TestTarget c(setup, "//foo:c", Target::STATIC_LIBRARY);
-  TestTarget d(setup, "//foo:d", Target::SOURCE_SET);
-  a.private_deps().push_back(LabelTargetPair(&b));
-  b.private_deps().push_back(LabelTargetPair(&c));
-  c.private_deps().push_back(LabelTargetPair(&d));
-
-  ASSERT_TRUE(d.OnResolved(&err));
-  ASSERT_TRUE(c.OnResolved(&err));
-  ASSERT_TRUE(b.OnResolved(&err));
-  ASSERT_TRUE(a.OnResolved(&err));
-
-  // C should have D in its inherited libs.
-  std::vector<const Target*> c_inherited = c.inherited_libraries().GetOrdered();
-  ASSERT_EQ(1u, c_inherited.size());
-  EXPECT_EQ(&d, c_inherited[0]);
-
-  // B should have C and D in its inherited libs.
-  std::vector<const Target*> b_inherited = b.inherited_libraries().GetOrdered();
-  ASSERT_EQ(2u, b_inherited.size());
-  EXPECT_EQ(&c, b_inherited[0]);
-  EXPECT_EQ(&d, b_inherited[1]);
-
-  // A should have B in its inherited libs, but not any others (the shared
-  // library will include the static library and source set).
-  std::vector<const Target*> a_inherited = a.inherited_libraries().GetOrdered();
-  ASSERT_EQ(1u, a_inherited.size());
-  EXPECT_EQ(&b, a_inherited[0]);
-}
-
-TEST_F(TargetTest, InheritCompleteStaticLib) {
-  TestWithScope setup;
-  Err err;
-
-  // Create a dependency chain:
-  //   A (executable) -> B (complete static lib) -> C (source set)
-  TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
-  TestTarget b(setup, "//foo:b", Target::STATIC_LIBRARY);
-  b.set_complete_static_lib(true);
-
-  const LibFile lib("foo");
-  const SourceDir lib_dir("/foo_dir/");
-  TestTarget c(setup, "//foo:c", Target::SOURCE_SET);
-  c.config_values().libs().push_back(lib);
-  c.config_values().lib_dirs().push_back(lib_dir);
-
-  a.public_deps().push_back(LabelTargetPair(&b));
-  b.public_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.
-  std::vector<const Target*> b_inherited = b.inherited_libraries().GetOrdered();
-  ASSERT_EQ(1u, b_inherited.size());
-  EXPECT_EQ(&c, b_inherited[0]);
-
-  // A should have B in its inherited libs, but not any others (the complete
-  // static library will include the source set).
-  std::vector<const Target*> a_inherited = a.inherited_libraries().GetOrdered();
-  ASSERT_EQ(1u, a_inherited.size());
-  EXPECT_EQ(&b, a_inherited[0]);
-
-  // A should inherit the libs and lib_dirs from the C.
-  ResolvedTargetData resolved;
-  const auto& a_all_libs = resolved.GetLinkedLibraries(&a);
-  ASSERT_EQ(1u, a_all_libs.size());
-  EXPECT_EQ(lib, a_all_libs[0]);
-
-  const auto& a_all_lib_dirs = resolved.GetLinkedLibraryDirs(&a);
-  ASSERT_EQ(1u, a_all_lib_dirs.size());
-  EXPECT_EQ(lib_dir, a_all_lib_dirs[0]);
-}
-
-TEST_F(TargetTest, InheritCompleteStaticLibStaticLibDeps) {
-  TestWithScope setup;
-  Err err;
-
-  // Create a dependency chain:
-  //   A (executable) -> B (complete static lib) -> C (static lib)
-  TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
-  TestTarget b(setup, "//foo:b", Target::STATIC_LIBRARY);
-  b.set_complete_static_lib(true);
-  TestTarget c(setup, "//foo:c", Target::STATIC_LIBRARY);
-  a.public_deps().push_back(LabelTargetPair(&b));
-  b.public_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.
-  std::vector<const Target*> b_inherited = b.inherited_libraries().GetOrdered();
-  ASSERT_EQ(1u, b_inherited.size());
-  EXPECT_EQ(&c, b_inherited[0]);
-
-  // A should have B in its inherited libs, but not any others (the complete
-  // static library will include the static library).
-  std::vector<const Target*> a_inherited = a.inherited_libraries().GetOrdered();
-  ASSERT_EQ(1u, a_inherited.size());
-  EXPECT_EQ(&b, a_inherited[0]);
-}
-
-TEST_F(TargetTest, InheritCompleteStaticLibInheritedCompleteStaticLibDeps) {
-  TestWithScope setup;
-  Err err;
-
-  // Create a dependency chain:
-  //   A (executable) -> B (complete static lib) -> C (complete static lib)
-  TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
-  TestTarget b(setup, "//foo:b", Target::STATIC_LIBRARY);
-  b.set_complete_static_lib(true);
-  TestTarget c(setup, "//foo:c", Target::STATIC_LIBRARY);
-  c.set_complete_static_lib(true);
-
-  a.private_deps().push_back(LabelTargetPair(&b));
-  b.private_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.
-  std::vector<const Target*> b_inherited = b.inherited_libraries().GetOrdered();
-  ASSERT_EQ(1u, b_inherited.size());
-  EXPECT_EQ(&c, b_inherited[0]);
-
-  // A should have B and C in its inherited libs.
-  std::vector<const Target*> a_inherited = a.inherited_libraries().GetOrdered();
-  ASSERT_EQ(2u, a_inherited.size());
-  EXPECT_EQ(&b, a_inherited[0]);
-  EXPECT_EQ(&c, a_inherited[1]);
-}
-
-TEST_F(TargetTest, NoActionDepPropgation) {
-  TestWithScope setup;
-  Err err;
-
-  // Create a dependency chain:
-  //   A (exe) -> B (action) -> C (source_set)
-  {
-    TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
-    TestTarget b(setup, "//foo:b", Target::ACTION);
-    TestTarget c(setup, "//foo:c", Target::SOURCE_SET);
-
-    a.private_deps().push_back(LabelTargetPair(&b));
-    b.private_deps().push_back(LabelTargetPair(&c));
-
-    ASSERT_TRUE(c.OnResolved(&err));
-    ASSERT_TRUE(b.OnResolved(&err));
-    ASSERT_TRUE(a.OnResolved(&err));
-
-    // The executable should not have inherited the source set across the
-    // action.
-    std::vector<const Target*> libs = a.inherited_libraries().GetOrdered();
-    ASSERT_TRUE(libs.empty());
-  }
-}
-
 TEST_F(TargetTest, GetComputedOutputName) {
   TestWithScope setup;
   Err err;
@@ -934,48 +767,6 @@
   EXPECT_EQ("//out/Debug/one", computed_outputs[0].value());
 }
 
-// Shared libraries should be inherited across public shared library
-// boundaries.
-TEST_F(TargetTest, SharedInheritance) {
-  TestWithScope setup;
-  Err err;
-
-  // Create two leaf shared libraries.
-  TestTarget pub(setup, "//foo:pub", Target::SHARED_LIBRARY);
-  ASSERT_TRUE(pub.OnResolved(&err));
-
-  TestTarget priv(setup, "//foo:priv", Target::SHARED_LIBRARY);
-  ASSERT_TRUE(priv.OnResolved(&err));
-
-  // Intermediate shared library with the leaf shared libraries as
-  // dependencies, one public, one private.
-  TestTarget inter(setup, "//foo:inter", Target::SHARED_LIBRARY);
-  inter.public_deps().push_back(LabelTargetPair(&pub));
-  inter.private_deps().push_back(LabelTargetPair(&priv));
-  ASSERT_TRUE(inter.OnResolved(&err));
-
-  // The intermediate shared library should have both "pub" and "priv" in its
-  // inherited libraries.
-  std::vector<const Target*> inter_inherited =
-      inter.inherited_libraries().GetOrdered();
-  ASSERT_EQ(2u, inter_inherited.size());
-  EXPECT_EQ(&pub, inter_inherited[0]);
-  EXPECT_EQ(&priv, inter_inherited[1]);
-
-  // Make a toplevel executable target depending on the intermediate one.
-  TestTarget exe(setup, "//foo:exe", Target::SHARED_LIBRARY);
-  exe.private_deps().push_back(LabelTargetPair(&inter));
-  ASSERT_TRUE(exe.OnResolved(&err));
-
-  // The exe's inherited libraries should be "inter" (because it depended
-  // directly on it) and "pub" (because inter depended publicly on it).
-  std::vector<const Target*> exe_inherited =
-      exe.inherited_libraries().GetOrdered();
-  ASSERT_EQ(2u, exe_inherited.size());
-  EXPECT_EQ(&inter, exe_inherited[0]);
-  EXPECT_EQ(&pub, exe_inherited[1]);
-}
-
 TEST_F(TargetTest, GeneratedInputs) {
   TestWithScope setup;
   Err err;