diff --git a/src/gn/ninja_rust_binary_target_writer.cc b/src/gn/ninja_rust_binary_target_writer.cc
index 6b9c2dc..06bce2f 100644
--- a/src/gn/ninja_rust_binary_target_writer.cc
+++ b/src/gn/ninja_rust_binary_target_writer.cc
@@ -180,8 +180,9 @@
   // on, and the public flag represents if the target has direct access to the
   // dependency through a chain of public_deps.
   std::vector<ExternCrate> transitive_crates;
-  for (const auto& [dep, has_direct_access] :
-       target_->rust_transitive_inherited_libs().GetOrderedAndPublicFlag()) {
+  for (const auto& inherited : resolved().GetRustInheritedLibraries(target_)) {
+    const Target* dep = inherited.target();
+    bool has_direct_access = inherited.is_public();
     // We will tell rustc to look for crate metadata for any rust crate
     // dependencies except cdylibs, as they have no metadata present.
     if (dep->source_types_used().RustSourceUsed() &&
diff --git a/src/gn/resolved_target_data.cc b/src/gn/resolved_target_data.cc
index d944123..b2692e7 100644
--- a/src/gn/resolved_target_data.cc
+++ b/src/gn/resolved_target_data.cc
@@ -171,3 +171,55 @@
     }
   }
 }
+
+void ResolvedTargetData::ComputeRustLibs(TargetInfo* info) const {
+  RustLibsBuilder rust_libs;
+
+  ComputeRustLibsFor(info->deps.public_deps(), true, &rust_libs);
+  ComputeRustLibsFor(info->deps.private_deps(), false, &rust_libs);
+
+  info->rust_inherited_libs = rust_libs.inherited.Build();
+  info->rust_inheritable_libs = rust_libs.inheritable.Build();
+  info->has_rust_libs = true;
+}
+
+void ResolvedTargetData::ComputeRustLibsFor(base::span<const Target*> deps,
+                                            bool is_public,
+                                            RustLibsBuilder* rust_libs) const {
+  for (const Target* dep : deps) {
+    // Collect Rust libraries that are accessible from the current target, or
+    // transitively part of the current target.
+    if (dep->output_type() == Target::STATIC_LIBRARY ||
+        dep->output_type() == Target::SHARED_LIBRARY ||
+        dep->output_type() == Target::SOURCE_SET ||
+        dep->output_type() == Target::RUST_LIBRARY ||
+        dep->output_type() == Target::GROUP) {
+      // Here we have: `this` --[depends-on]--> `dep`
+      //
+      // The `this` target has direct access to `dep` since its a direct
+      // dependency, regardless of the edge being a public_dep or not, so we
+      // pass true for public-ness. Whereas, anything depending on `this` can
+      // only gain direct access to `dep` if the edge between `this` and `dep`
+      // is public, so we pass `is_public`.
+      //
+      // TODO(danakj): We should only need to track Rust rlibs or dylibs here,
+      // as it's used for passing to rustc with --extern. We currently track
+      // everything then drop non-Rust libs in
+      // ninja_rust_binary_target_writer.cc.
+      rust_libs->inherited.Append(dep, true);
+      rust_libs->inheritable.Append(dep, is_public);
+
+      const TargetInfo* dep_info = GetTargetRustLibs(dep);
+      rust_libs->inherited.AppendInherited(dep_info->rust_inheritable_libs,
+                                           true);
+      rust_libs->inheritable.AppendInherited(dep_info->rust_inheritable_libs,
+                                             is_public);
+    } else if (dep->output_type() == Target::RUST_PROC_MACRO) {
+      // Proc-macros are inherited as a transitive dependency, but the things
+      // they depend on can't be used elsewhere, as the proc macro is not
+      // linked into the target (as it's only used during compilation).
+      rust_libs->inherited.Append(dep, true);
+      rust_libs->inheritable.Append(dep, is_public);
+    }
+  }
+}
diff --git a/src/gn/resolved_target_data.h b/src/gn/resolved_target_data.h
index 0dc36be..f8f6458 100644
--- a/src/gn/resolved_target_data.h
+++ b/src/gn/resolved_target_data.h
@@ -110,6 +110,13 @@
     return GetTargetInheritedLibs(target)->inherited_libs;
   }
 
+  // Retrieves an ordered list of (target, is_public) paris for all link-time
+  // libraries for Rust-specific binary targets.
+  const std::vector<TargetPublicPair>& GetRustInheritedLibraries(
+      const Target* target) const {
+    return GetTargetRustLibs(target)->rust_inherited_libs;
+  }
+
  private:
   // The information associated with a given Target pointer.
   struct TargetInfo {
@@ -128,6 +135,7 @@
     bool has_framework_info = false;
     bool has_hard_deps = false;
     bool has_inherited_libs = false;
+    bool has_rust_libs = false;
 
     // Only valid if |has_lib_info| is true.
     std::vector<SourceDir> lib_dirs;
@@ -143,6 +151,10 @@
 
     // Only valid if |has_inherited_libs| is true.
     std::vector<TargetPublicPair> inherited_libs;
+
+    // Only valid if |has_rust_libs| is true.
+    std::vector<TargetPublicPair> rust_inherited_libs;
+    std::vector<TargetPublicPair> rust_inheritable_libs;
   };
 
   // Retrieve TargetInfo value associated with |target|. Create
@@ -185,6 +197,15 @@
     return info;
   }
 
+  const TargetInfo* GetTargetRustLibs(const Target* target) const {
+    TargetInfo* info = GetTargetInfo(target);
+    if (!info->has_rust_libs) {
+      ComputeRustLibs(info);
+      DCHECK(info->has_rust_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.
@@ -192,13 +213,24 @@
   void ComputeFrameworkInfo(TargetInfo* info) const;
   void ComputeHardDeps(TargetInfo* info) const;
   void ComputeInheritedLibs(TargetInfo* info) const;
+  void ComputeRustLibs(TargetInfo* info) const;
 
-  // Helper function usde by ComputeInheritedLibs().
+  // Helper function used by ComputeInheritedLibs().
   void ComputeInheritedLibsFor(
       base::span<const Target*> deps,
       bool is_public,
       TargetPublicPairListBuilder* inherited_libraries) const;
 
+  // Helper data structure and function used by ComputeRustLibs().
+  struct RustLibsBuilder {
+    TargetPublicPairListBuilder inherited;
+    TargetPublicPairListBuilder inheritable;
+  };
+
+  void ComputeRustLibsFor(base::span<const Target*> deps,
+                          bool is_public,
+                          RustLibsBuilder* rust_libs) const;
+
   // A { Target* -> TargetInfo } map that will create entries
   // on demand (hence the mutable qualifier). Implemented with a
   // UniqueVector<> and a parallel vector of unique TargetInfo
diff --git a/src/gn/rust_values.h b/src/gn/rust_values.h
index d201014..52a7623 100644
--- a/src/gn/rust_values.h
+++ b/src/gn/rust_values.h
@@ -8,7 +8,6 @@
 #include <map>
 
 #include "base/containers/flat_map.h"
-#include "gn/inherited_libraries.h"
 #include "gn/label.h"
 #include "gn/source_file.h"
 
diff --git a/src/gn/target.cc b/src/gn/target.cc
index 5bdfdef..f73cd3a 100644
--- a/src/gn/target.cc
+++ b/src/gn/target.cc
@@ -484,7 +484,6 @@
   }
 
   PullRecursiveBundleData();
-  PullDependentTargetLibs();
   if (!ResolvePrecompiledHeaders(err))
     return false;
 
@@ -738,47 +737,6 @@
   }
 }
 
-void Target::PullDependentTargetLibsFrom(const Target* dep, bool 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 ||
-      dep->output_type() == SHARED_LIBRARY ||
-      dep->output_type() == SOURCE_SET || dep->output_type() == RUST_LIBRARY ||
-      dep->output_type() == GROUP) {
-    // Here we have: `this` --[depends-on]--> `dep`
-    //
-    // The `this` target has direct access to `dep` since its a direct
-    // dependency, regardless of the edge being a public_dep or not, so we pass
-    // true for public-ness. Whereas, anything depending on `this` can only gain
-    // direct access to `dep` if the edge between `this` and `dep` is public, so
-    // we pass `is_public`.
-    //
-    // TODO(danakj): We should only need to track Rust rlibs or dylibs here, as
-    // it's used for passing to rustc with --extern. We currently track
-    // everything then drop non-Rust libs in ninja_rust_binary_target_writer.cc.
-    rust_transitive_inherited_libs_.Append(dep, true);
-    rust_transitive_inheritable_libs_.Append(dep, is_public);
-
-    rust_transitive_inherited_libs_.AppendInherited(
-        dep->rust_transitive_inheritable_libs(), true);
-    rust_transitive_inheritable_libs_.AppendInherited(
-        dep->rust_transitive_inheritable_libs(), is_public);
-  } else if (dep->output_type() == RUST_PROC_MACRO) {
-    // Proc-macros are inherited as a transitive dependency, but the things they
-    // depend on can't be used elsewhere, as the proc macro is not linked into
-    // the target (as it's only used during compilation).
-    rust_transitive_inherited_libs_.Append(dep, true);
-    rust_transitive_inheritable_libs_.Append(dep, is_public);
-  }
-}
-
-void Target::PullDependentTargetLibs() {
-  for (const auto& dep : public_deps_)
-    PullDependentTargetLibsFrom(dep.ptr, true);
-  for (const auto& dep : private_deps_)
-    PullDependentTargetLibsFrom(dep.ptr, false);
-}
-
 void Target::PullRecursiveBundleData() {
   for (const auto& pair : GetDeps(DEPS_LINKED)) {
     // Don't propagate bundle_data once they are added to a bundle.
diff --git a/src/gn/target.h b/src/gn/target.h
index 348f49f..806d14b 100644
--- a/src/gn/target.h
+++ b/src/gn/target.h
@@ -319,14 +319,6 @@
   const RustValues& rust_values() const;
   bool has_rust_values() const { return rust_values_.get(); }
 
-  // Transitive closure of libraries that are depended on by this target
-  const InheritedLibraries& rust_transitive_inherited_libs() const {
-    return rust_transitive_inherited_libs_;
-  }
-  const InheritedLibraries& rust_transitive_inheritable_libs() const {
-    return rust_transitive_inheritable_libs_;
-  }
-
   std::vector<LabelPattern>& friends() { return friends_; }
   const std::vector<LabelPattern>& friends() const { return friends_; }
 
@@ -494,19 +486,6 @@
   // Used for Rust targets.
   std::unique_ptr<RustValues> rust_values_;
 
-  // Used by all targets, only useful to generate Rust targets though. These
-  // present 2 different views of the public flags:
-  //
-  // Lists all transitive libraries, and for each one the public bit says if
-  // there is a public chain such that this target can make direct use of the
-  // lib. For each library marked public: "I have access to these targets."
-  InheritedLibraries rust_transitive_inherited_libs_;
-  // Lists all transitive libraries, and for each one the public bit says if a
-  // target depending on this target would inherit the libraries as public too.
-  // For each library marked public: "If you depend on me, you get access to
-  // these targets."
-  InheritedLibraries rust_transitive_inheritable_libs_;
-
   // User for Swift targets.
   std::unique_ptr<SwiftValues> swift_values_;