diff --git a/build/gen.py b/build/gen.py
index ce600e7..c7a73a8 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -681,7 +681,6 @@
         'src/gn/pattern.cc',
         'src/gn/pool.cc',
         'src/gn/qt_creator_writer.cc',
-        'src/gn/resolved_target_data.cc',
         'src/gn/runtime_deps.cc',
         'src/gn/rust_substitution_type.cc',
         'src/gn/rust_tool.cc',
@@ -770,7 +769,6 @@
         'src/gn/functions_unittest.cc',
         'src/gn/hash_table_base_unittest.cc',
         'src/gn/header_checker_unittest.cc',
-        'src/gn/immutable_vector_unittest.cc',
         'src/gn/inherited_libraries_unittest.cc',
         'src/gn/input_conversion_unittest.cc',
         'src/gn/json_project_writer_unittest.cc',
@@ -801,8 +799,6 @@
         'src/gn/path_output_unittest.cc',
         'src/gn/pattern_unittest.cc',
         'src/gn/pointer_set_unittest.cc',
-        'src/gn/resolved_target_data_unittest.cc',
-        'src/gn/resolved_target_deps_unittest.cc',
         'src/gn/runtime_deps_unittest.cc',
         'src/gn/scope_per_file_provider_unittest.cc',
         'src/gn/scope_unittest.cc',
@@ -814,9 +810,7 @@
         'src/gn/string_utils_unittest.cc',
         'src/gn/substitution_pattern_unittest.cc',
         'src/gn/substitution_writer_unittest.cc',
-        'src/gn/tagged_pointer_unittest.cc',
         'src/gn/target_unittest.cc',
-        'src/gn/target_public_pair_unittest.cc',
         'src/gn/template_unittest.cc',
         'src/gn/test_with_scheduler.cc',
         'src/gn/test_with_scope.cc',
@@ -830,7 +824,6 @@
         'src/gn/visual_studio_writer_unittest.cc',
         'src/gn/xcode_object_unittest.cc',
         'src/gn/xml_element_writer_unittest.cc',
-        'src/util/aligned_alloc_unittest.cc',
         'src/util/test/gn_test.cc',
       ], 'libs': []},
   }
diff --git a/src/gn/immutable_vector.h b/src/gn/immutable_vector.h
deleted file mode 100644
index 0897bec..0000000
--- a/src/gn/immutable_vector.h
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright 2022 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.
-
-#ifndef TOOLS_GN_IMMUTABLE_VECTOR_H_
-#define TOOLS_GN_IMMUTABLE_VECTOR_H_
-
-#include <cstdlib>
-#include <type_traits>
-#include <utility>
-
-#include "util/aligned_alloc.h"
-
-// An ImmutableVector<T> represents a fixed-size vector of constant items of
-// type T. The in-memory representation is more efficient, only using one
-// pointer to a single heap-allocated memory block that also contains the size.
-//
-// An ImmutableVectorView<T> acts as a copyable and movable reference to another
-// ImmutableVector<T> instance. They both point to the same memory in the heap,
-// but the view is not owning and is invalidated when the instance it points to
-// is destroyed.
-//
-// Apart from that, they can be used with the same methods as a  const
-// std::vector<T>.
-//
-template <typename T>
-class ImmutableVector;
-
-template <typename T>
-class ImmutableVectorView {
- public:
-  // Default constructor
-  ImmutableVectorView() = default;
-
-  // Constructor from an ImmutableVector.
-  ImmutableVectorView(const ImmutableVector<T>& vector)
-      : header_(vector.header_) {}
-
-  // Usual methods to access items.
-  const T* data() const { return begin(); }
-  size_t size() const { return header_ ? header_->size : 0u; }
-  bool empty() const { return size() == 0; }
-  const T& operator[](size_t offset) const { return begin()[offset]; }
-
-  const T* begin() const { return header_ ? &header_->item0 : nullptr; }
-  const T* end() const {
-    return header_ ? &header_->item0 + header_->size : nullptr;
-  }
-
-  const T& front() const { return begin()[0]; }
-  const T& back() const { return end()[-1]; }
-
-  // For use with standard algorithms and templates.
-  using element_type = T;
-  using value_type = std::remove_cv_t<T>;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using reference = T&;
-  using const_reference = const T&;
-  using iterator = const T*;
-  using const_iterator = const T*;
-
-  const_iterator find(const T& item) const {
-    auto it = begin();
-    auto it_end = end();
-    for (; it != it_end; ++it) {
-      if (*it == item)
-        break;
-    }
-    return it;
-  }
-
-  bool contains(const T& item) const {
-    for (const auto& cur_item : *this)
-      if (cur_item == item)
-        return true;
-
-    return false;
-  }
-
- protected:
-  struct Header {
-    size_t size;
-    T item0;
-  };
-
-  ImmutableVectorView(Header* header) : header_(header) {}
-
-  Header* header_ = nullptr;
-};
-
-template <typename T>
-class ImmutableVector : public ImmutableVectorView<T> {
- public:
-  // Default constructor.
-  ImmutableVector() = default;
-
-  // Range constructors.
-  ImmutableVector(const T* begin, size_t size)
-      : ImmutableVectorView<T>(AllocateAndCopyFrom(begin, size)) {}
-
-  ImmutableVector(const T* begin, const T* end)
-      : ImmutableVector(begin, end - begin) {}
-
-  // In-place constructor
-  // |producer| must be a callable that generates a T instance that will
-  // be used to construct items in place in the allocated vector.
-  template <typename P,
-            typename = std::void_t<
-                decltype(static_cast<const T&>(std::declval<P>()()))>>
-  ImmutableVector(P producer, size_t size) {
-    if (size) {
-      this->header_ = AllocateFor(size);
-      auto* dst = &(this->header_->item0);
-      auto* dst_limit = dst + size;
-      for (; dst != dst_limit; ++dst)
-        new (dst) T(producer());
-    }
-  }
-
-  // Container constructor
-  //
-  // This uses std::void_t<> to select container types whose values
-  // are convertible to |const T&|, and which have |begin()| and |size()|
-  // methods.
-  //
-  // This constructor copies items from the constructor into the
-  // ImmutableVector.
-  template <typename C,
-            typename = std::void_t<
-                decltype(static_cast<const T>(*std::declval<C>().begin())),
-                decltype(std::declval<C>().size())>>
-  ImmutableVector(const C& container) {
-    size_t size = container.size();
-    if (size) {
-      this->header_ = AllocateFor(size);
-      auto src = container.begin();
-      auto* dst = &(this->header_->item0);
-      auto* dst_limit = dst + size;
-      for (; dst != dst_limit; ++dst, ++src) {
-        new (dst) T(*src);
-      }
-    }
-  }
-
-  // Another container constructor where the items can be moved into
-  // the resulting ImmutableVector.
-  template <typename C,
-            typename = std::void_t<
-                decltype(static_cast<const T>(*std::declval<C>().begin())),
-                decltype(std::declval<C>().size())>>
-  ImmutableVector(C&& container) {
-    size_t size = container.size();
-    if (size) {
-      this->header_ = AllocateFor(size);
-      auto src = container.begin();
-      auto* dst = &(this->header_->item0);
-      auto* dst_limit = dst + size;
-      for (; dst != dst_limit; ++dst, ++src)
-        new (dst) T(std::move(*src));
-    }
-  }
-
-  // Initializer-list container.
-  ImmutableVector(std::initializer_list<T> list)
-      : ImmutableVector(list.begin(), list.size()) {}
-
-  // Copy operations
-  ImmutableVector(const ImmutableVector& other)
-      : ImmutableVectorView<T>(
-            AllocateAndCopyFrom(other.begin(), other.size())) {}
-
-  ImmutableVector& operator=(const ImmutableVector& other) {
-    if (this != &other) {
-      this->~ImmutableVector();
-      new (this) ImmutableVector(other);
-    }
-    return *this;
-  }
-
-  // Move operations
-  ImmutableVector(ImmutableVector&& other) noexcept {
-    this->header_ = other.header_;
-    other.header_ = nullptr;
-  }
-
-  ImmutableVector& operator=(ImmutableVector&& other) noexcept {
-    if (this != &other) {
-      this->~ImmutableVector();
-      new (this) ImmutableVector(std::move(other));
-    }
-    return *this;
-  }
-
-  // Destructor
-  ~ImmutableVector() {
-    if (this->header_) {
-      auto* cur = &(this->header_->item0);
-      auto* limit = cur + this->size();
-      while (cur != limit) {
-        (*cur).~T();
-        cur++;
-      }
-      Allocator::Free(this->header_);
-    }
-  }
-
- protected:
-  friend class ImmutableVectorView<T>;
-
-  using Header = typename ImmutableVectorView<T>::Header;
-
-  // Don't use std::max() here to avoid including <algorithm> which is massive.
-  static constexpr size_t kAlignment = alignof(T) > alignof(Header)
-                                           ? alignof(T)
-                                           : alignof(Header);
-
-  using Allocator = AlignedAlloc<kAlignment>;
-
-  static Header* AllocateFor(size_t count) {
-    if (!count)
-      return nullptr;
-
-    auto* header = reinterpret_cast<Header*>(
-        Allocator::Alloc(sizeof(Header) + (count - 1u) * sizeof(T)));
-    header->size = count;
-    return header;
-  }
-
-  static Header* AllocateAndCopyFrom(const T* begin, size_t size) {
-    Header* header = AllocateFor(size);
-    if (size) {
-      T* dst = &(header->item0);
-      T* limit = dst + size;
-      for (; dst != limit; ++dst, ++begin)
-        new (dst) T(*begin);
-    }
-    return header;
-  }
-};
-
-#endif  // TOOLS_GN_IMMUTABLE_VECTOR_H_
diff --git a/src/gn/immutable_vector_unittest.cc b/src/gn/immutable_vector_unittest.cc
deleted file mode 100644
index 3561ed2..0000000
--- a/src/gn/immutable_vector_unittest.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2022 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 "gn/immutable_vector.h"
-#include "util/test/test.h"
-
-#include <set>
-#include <vector>
-
-TEST(ImmutableVector, CreationDestruction) {
-  ImmutableVector<int> empty;
-  EXPECT_TRUE(empty.empty());
-  EXPECT_EQ(0u, empty.size());
-
-  ImmutableVector<int> vec1 = {100, 42};
-  EXPECT_FALSE(vec1.empty());
-  EXPECT_EQ(2u, vec1.size());
-  EXPECT_EQ(100, vec1.front());
-  EXPECT_EQ(42, vec1.back());
-  EXPECT_EQ(100, vec1[0]);
-  EXPECT_EQ(42, vec1[1]);
-  EXPECT_TRUE(vec1.begin());
-  EXPECT_TRUE(vec1.end());
-  EXPECT_NE(vec1.begin(), vec1.end());
-  EXPECT_EQ(vec1.begin() + 2, vec1.end());
-
-  std::vector<int> input;
-  input.push_back(100);
-  input.push_back(42);
-  input.push_back(-12);
-  ImmutableVector<int> vec2(input);
-  EXPECT_FALSE(vec2.empty());
-  EXPECT_EQ(3u, vec2.size());
-  EXPECT_EQ(100, vec2.front());
-  EXPECT_EQ(100, vec2[0]);
-  EXPECT_EQ(42, vec2[1]);
-  EXPECT_EQ(-12, vec2[2]);
-  EXPECT_NE(vec2.begin(), &input[0]);
-  EXPECT_NE(vec2.end(), &input[0] + 3);
-}
-
-TEST(ImmutableVetor, InPlaceConstruction) {
-  size_t count = 0;
-  auto count_producer = [&count]() { return count++; };
-  ImmutableVector<int> vec(count_producer, 5u);
-  EXPECT_EQ(5u, vec.size());
-  EXPECT_EQ(0, vec[0]);
-  EXPECT_EQ(1, vec[1]);
-  EXPECT_EQ(2, vec[2]);
-  EXPECT_EQ(3, vec[3]);
-  EXPECT_EQ(4, vec[4]);
-}
-
-TEST(ImmutableVector, CopyAndMoveOperations) {
-  ImmutableVector<int> vec1 = {1, 2, 3, 4};
-  ImmutableVector<int> vec2 = vec1;
-  ImmutableVector<int> vec3 = std::move(vec1);
-
-  EXPECT_TRUE(vec1.empty());
-  EXPECT_EQ(4u, vec2.size());
-  EXPECT_EQ(4u, vec3.size());
-  EXPECT_NE(vec2.begin(), vec3.begin());
-  EXPECT_NE(vec2.end(), vec3.end());
-  EXPECT_TRUE(std::equal(vec2.begin(), vec2.end(), vec3.begin(), vec3.end()));
-}
-
-TEST(ImmutableVectorView, Creation) {
-  ImmutableVector<int> vec1 = {1, 3, 5, 7};
-  ImmutableVectorView<int> view1 = vec1;
-  ImmutableVectorView<int> view2(view1);
-
-  EXPECT_EQ(vec1.size(), view1.size());
-  EXPECT_EQ(vec1.size(), view2.size());
-
-  EXPECT_EQ(vec1.begin(), view1.begin());
-  EXPECT_EQ(vec1.end(), view1.end());
-
-  EXPECT_EQ(vec1.begin(), view2.begin());
-  EXPECT_EQ(vec1.end(), view2.end());
-}
diff --git a/src/gn/resolved_target_data.cc b/src/gn/resolved_target_data.cc
deleted file mode 100644
index 93064f9..0000000
--- a/src/gn/resolved_target_data.cc
+++ /dev/null
@@ -1,461 +0,0 @@
-// Copyright 2022 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 "gn/resolved_target_data.h"
-
-#include "gn/config_values_extractors.h"
-#include "gn/resolved_target_deps.h"
-
-using LibInfo = ResolvedTargetData::LibInfo;
-using FrameworkInfo = ResolvedTargetData::FrameworkInfo;
-
-namespace {
-
-struct TargetInfo {
-  TargetInfo() = default;
-
-  TargetInfo(const Target* target)
-      : target(target),
-        deps(target->public_deps(),
-             target->private_deps(),
-             target->data_deps()) {}
-
-  const Target* target = nullptr;
-  ResolvedTargetDeps deps;
-
-  bool has_lib_info = false;
-  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|.
-  ImmutableVector<SourceDir> lib_dirs;
-  ImmutableVector<LibFile> libs;
-
-  // Only valid if |has_framework_info|.
-  ImmutableVector<SourceDir> framework_dirs;
-  ImmutableVector<std::string> frameworks;
-  ImmutableVector<std::string> weak_frameworks;
-
-  // Only valid if |has_hard_deps|.
-  ImmutableVector<const Target*> hard_deps;
-
-  // Only valid if |has_inherited_libs|.
-  ImmutableVector<TargetPublicPair> inherited_libs;
-
-  // Only valid if |has_rust_libs|.
-  ImmutableVector<TargetPublicPair> rust_inherited_libs;
-  ImmutableVector<TargetPublicPair> rust_inheritable_libs;
-};
-
-}  // namespace
-
-// Implementation class for ResolvedTargetData.
-class ResolvedTargetData::Impl {
- public:
-  LibInfo GetLibInfo(const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetLibInfo(target);
-    DCHECK(info->has_lib_info);
-    return LibInfo{
-        info->lib_dirs,
-        info->libs,
-    };
-  }
-
-  ImmutableVectorView<SourceDir> all_lib_dirs(const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetLibInfo(target);
-    DCHECK(info->has_lib_info);
-    return info->lib_dirs;
-  }
-
-  ImmutableVectorView<LibFile> all_libs(const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetLibInfo(target);
-    DCHECK(info->has_lib_info);
-    return info->libs;
-  }
-
-  FrameworkInfo GetFrameworkInfo(const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetFrameworkInfo(target);
-    DCHECK(info->has_framework_info);
-    return FrameworkInfo{
-        info->framework_dirs,
-        info->frameworks,
-        info->weak_frameworks,
-    };
-  }
-
-  ImmutableVectorView<SourceDir> all_framework_dirs(
-      const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetFrameworkInfo(target);
-    DCHECK(info->has_framework_info);
-    return info->framework_dirs;
-  }
-
-  ImmutableVectorView<std::string> all_frameworks(const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetFrameworkInfo(target);
-    DCHECK(info->has_framework_info);
-    return info->frameworks;
-  }
-
-  ImmutableVectorView<std::string> all_weak_frameworks(
-      const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetFrameworkInfo(target);
-    DCHECK(info->has_framework_info);
-    return info->weak_frameworks;
-  }
-
-  TargetSet recursive_hard_deps(const Target* target) const {
-    TargetInfo* info = GetInfo(target);
-    DCHECK(info->has_hard_deps);
-    if (!info->has_hard_deps)
-      ComputeHardDeps(info);
-
-    return TargetSet(info->hard_deps.begin(), info->hard_deps.end());
-  }
-
-  ImmutableVectorView<TargetPublicPair> inherited_libraries(
-      const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetInheritedLibs(target);
-    DCHECK(info->has_inherited_libs);
-    return info->inherited_libs;
-  }
-
-  ImmutableVectorView<TargetPublicPair> rust_transitive_inherited_libs(
-      const Target* target) const {
-    const TargetInfo* info = GetRecursiveTargetRustLibs(target);
-    DCHECK(info->has_rust_libs);
-    return info->rust_inherited_libs;
-  }
-
- private:
-  const TargetInfo* GetRecursiveTargetLibInfo(const Target* target) const {
-    TargetInfo* info = GetInfo(target);
-    if (!info->has_lib_info)
-      ComputeLibInfo(info);
-    return info;
-  }
-
-  void ComputeLibInfo(TargetInfo* info) const {
-    UniqueVector<SourceDir> all_lib_dirs;
-    UniqueVector<LibFile> all_libs;
-
-    for (ConfigValuesIterator iter(info->target); !iter.done(); iter.Next()) {
-      const ConfigValues& cur = iter.cur();
-      all_lib_dirs.Append(cur.lib_dirs());
-      all_libs.Append(cur.libs());
-    }
-    for (const Target* dep : info->deps.linked_deps()) {
-      if (!dep->IsFinal() || dep->output_type() == Target::STATIC_LIBRARY) {
-        const TargetInfo* dep_info = GetRecursiveTargetLibInfo(dep);
-        all_lib_dirs.Append(dep_info->lib_dirs);
-        all_libs.Append(dep_info->libs);
-      }
-    }
-
-    info->lib_dirs = ImmutableVector<SourceDir>(all_lib_dirs.release());
-    info->libs = ImmutableVector<LibFile>(all_libs.release());
-    info->has_lib_info = true;
-  }
-
-  const TargetInfo* GetRecursiveTargetFrameworkInfo(
-      const Target* target) const {
-    TargetInfo* info = GetInfo(target);
-    if (!info->has_framework_info)
-      ComputeFrameworkInfo(info);
-    return info;
-  }
-
-  void ComputeFrameworkInfo(TargetInfo* info) const {
-    UniqueVector<SourceDir> all_framework_dirs;
-    UniqueVector<std::string> all_frameworks;
-    UniqueVector<std::string> all_weak_frameworks;
-
-    for (ConfigValuesIterator iter(info->target); !iter.done(); iter.Next()) {
-      const ConfigValues& cur = iter.cur();
-      all_framework_dirs.Append(cur.framework_dirs());
-      all_frameworks.Append(cur.frameworks());
-      all_weak_frameworks.Append(cur.weak_frameworks());
-    }
-    for (const Target* dep : info->deps.linked_deps()) {
-      if (!dep->IsFinal() || dep->output_type() == Target::STATIC_LIBRARY) {
-        const TargetInfo* dep_info = GetRecursiveTargetLibInfo(dep);
-        all_framework_dirs.Append(dep_info->framework_dirs);
-        all_frameworks.Append(dep_info->frameworks);
-        all_weak_frameworks.Append(dep_info->weak_frameworks);
-      }
-    }
-
-    info->framework_dirs = ImmutableVector<SourceDir>(all_framework_dirs);
-    info->frameworks = ImmutableVector<std::string>(all_frameworks);
-    info->weak_frameworks = ImmutableVector<std::string>(all_weak_frameworks);
-    info->has_framework_info = true;
-  }
-
-  const TargetInfo* GetRecursiveTargetHardDeps(const Target* target) const {
-    TargetInfo* info = GetInfo(target);
-    if (!info->has_hard_deps)
-      ComputeHardDeps(info);
-    return info;
-  }
-
-  void ComputeHardDeps(TargetInfo* info) const {
-    TargetSet all_hard_deps;
-    for (const Target* dep : info->deps.linked_deps()) {
-      // Direct hard dependencies
-      if (info->target->hard_dep() || dep->hard_dep()) {
-        all_hard_deps.insert(dep);
-        continue;
-      }
-      // If |dep| is binary target and |dep| has no public header,
-      // |this| target does not need to have |dep|'s hard_deps as its
-      // hard_deps to start compiles earlier. Unless the target compiles a
-      // Swift module (since they also generate a header that can be used
-      // by the current target).
-      if (dep->IsBinary() && !dep->all_headers_public() &&
-          dep->public_headers().empty() && !dep->builds_swift_module()) {
-        continue;
-      }
-
-      // Recursive hard dependencies of all dependencies.
-      const TargetInfo* dep_info = GetRecursiveTargetHardDeps(dep);
-      all_hard_deps.insert(dep_info->hard_deps.begin(),
-                           dep_info->hard_deps.end());
-    }
-    info->hard_deps = ImmutableVector<const Target*>(all_hard_deps);
-    info->has_hard_deps = true;
-  }
-
-  const TargetInfo* GetRecursiveTargetInheritedLibs(
-      const Target* target) const {
-    TargetInfo* info = GetInfo(target);
-    if (!info->has_inherited_libs)
-      ComputeInheritedLibs(info);
-    return info;
-  }
-
-  void ComputeInheritedLibs(TargetInfo* info) const {
-    TargetPublicPairListBuilder inherited_libraries;
-
-    ComputeInheritedLibsFor(info->deps.public_deps(), true,
-                            &inherited_libraries);
-    ComputeInheritedLibsFor(info->deps.private_deps(), false,
-                            &inherited_libraries);
-
-    info->has_inherited_libs = true;
-    info->inherited_libs = inherited_libraries.Build();
-  }
-
-  void 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 = GetRecursiveTargetInheritedLibs(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 = GetRecursiveTargetInheritedLibs(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 = GetRecursiveTargetInheritedLibs(dep);
-        for (const auto& pair : dep_info->inherited_libs) {
-          if (pair.target()->IsFinal())
-            inherited_libraries->Append(pair.target(),
-                                        is_public && pair.is_public());
-        }
-      }
-    }
-  }
-
-  const TargetInfo* GetRecursiveTargetRustLibs(const Target* target) const {
-    TargetInfo* info = GetInfo(target);
-    if (!info->has_rust_libs)
-      ComputeRustLibs(info);
-    return info;
-  }
-
-  struct RustLibsBuilder {
-    TargetPublicPairListBuilder inherited;
-    TargetPublicPairListBuilder inheritable;
-  };
-
-  void ComputeRustLibs(TargetInfo* info) const {
-    RustLibsBuilder rust_libs;
-
-    ComputeRustLibsFor(info->deps.public_deps(), true, &rust_libs);
-    ComputeRustLibsFor(info->deps.private_deps(), false, &rust_libs);
-
-    info->has_rust_libs = true;
-    info->rust_inherited_libs = rust_libs.inherited.Build();
-    info->rust_inheritable_libs = rust_libs.inheritable.Build();
-  }
-
-  void 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 = GetRecursiveTargetRustLibs(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);
-      }
-    }
-  }
-
-  TargetInfo* GetInfo(const Target* target) const {
-    auto ret = targets_.PushBackWithIndex(target);
-    if (!ret.first)
-      return infos_[ret.second].get();
-
-    infos_.push_back(std::make_unique<TargetInfo>(target));
-    return infos_.back().get();
-  }
-
-  // A { target -> TargetInfo } map that will create entries
-  // on demand. Implemented with a UniqueVector<> and a parallel
-  // vector of unique TargetInfo instances for best performance.
-  mutable UniqueVector<const Target*> targets_;
-  mutable std::vector<std::unique_ptr<TargetInfo>> infos_;
-};
-
-ResolvedTargetData::ResolvedTargetData() = default;
-
-ResolvedTargetData::~ResolvedTargetData() = default;
-
-ResolvedTargetData::ResolvedTargetData(ResolvedTargetData&&) noexcept = default;
-ResolvedTargetData& ResolvedTargetData::operator=(ResolvedTargetData&&) =
-    default;
-
-ResolvedTargetData::Impl* ResolvedTargetData::GetImpl() const {
-  if (!impl_)
-    impl_ = std::make_unique<ResolvedTargetData::Impl>();
-  return impl_.get();
-}
-
-LibInfo ResolvedTargetData::GetLibInfo(const Target* target) const {
-  return GetImpl()->GetLibInfo(target);
-}
-
-ImmutableVectorView<SourceDir> ResolvedTargetData::all_lib_dirs(
-    const Target* target) const {
-  return GetImpl()->all_lib_dirs(target);
-}
-
-ImmutableVectorView<LibFile> ResolvedTargetData::all_libs(
-    const Target* target) const {
-  return GetImpl()->all_libs(target);
-}
-
-FrameworkInfo ResolvedTargetData::GetFrameworkInfo(const Target* target) const {
-  return GetImpl()->GetFrameworkInfo(target);
-}
-
-ImmutableVectorView<SourceDir> ResolvedTargetData::all_framework_dirs(
-    const Target* target) const {
-  return GetImpl()->all_framework_dirs(target);
-}
-
-ImmutableVectorView<std::string> ResolvedTargetData::all_frameworks(
-    const Target* target) const {
-  return GetImpl()->all_frameworks(target);
-}
-
-ImmutableVectorView<std::string> ResolvedTargetData::all_weak_frameworks(
-    const Target* target) const {
-  return GetImpl()->all_weak_frameworks(target);
-}
-
-TargetSet ResolvedTargetData::recursive_hard_deps(const Target* target) const {
-  return GetImpl()->recursive_hard_deps(target);
-}
-
-TargetPublicPairList ResolvedTargetData::inherited_libraries(
-    const Target* target) const {
-  return GetImpl()->inherited_libraries(target);
-}
-
-TargetPublicPairList ResolvedTargetData::rust_transitive_inherited_libs(
-    const Target* target) const {
-  return GetImpl()->rust_transitive_inherited_libs(target);
-}
diff --git a/src/gn/resolved_target_data.h b/src/gn/resolved_target_data.h
deleted file mode 100644
index 67a616f..0000000
--- a/src/gn/resolved_target_data.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2022 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.
-
-#ifndef TOOLS_GN_RESOLVED_TARGET_DATA_H_
-#define TOOLS_GN_RESOLVED_TARGET_DATA_H_
-
-#include <memory>
-
-#include "gn/immutable_vector.h"
-#include "gn/lib_file.h"
-#include "gn/source_dir.h"
-#include "gn/tagged_pointer.h"
-#include "gn/target.h"
-#include "gn/target_public_pair.h"
-
-class Target;
-
-// A list of (target_ptr, is_public_flag) pairs as returned by methods
-// of ResolvedTargetData.
-using TargetPublicPairList = ImmutableVectorView<TargetPublicPair>;
-
-// A class used to compute data.
-class ResolvedTargetData {
- public:
-  ResolvedTargetData();
-  ~ResolvedTargetData();
-
-  // Move operations
-  ResolvedTargetData(ResolvedTargetData&&) noexcept;
-  ResolvedTargetData& operator=(ResolvedTargetData&&);
-
-  // Retrieve information about link-time libraries needed by this target.
-  struct LibInfo {
-    ImmutableVectorView<SourceDir> all_lib_dirs;
-    ImmutableVectorView<LibFile> all_libs;
-  };
-  LibInfo GetLibInfo(const Target*) const;
-
-  ImmutableVectorView<SourceDir> all_lib_dirs(const Target* target) const;
-
-  ImmutableVectorView<LibFile> all_libs(const Target* target) const;
-
-  // Retrieve information about link-time OS X frameworks needed by this target.
-  struct FrameworkInfo {
-    ImmutableVector<SourceDir> all_framework_dirs;
-    ImmutableVector<std::string> all_frameworks;
-    ImmutableVector<std::string> all_weak_frameworks;
-  };
-  FrameworkInfo GetFrameworkInfo(const Target* target) const;
-
-  ImmutableVectorView<SourceDir> all_framework_dirs(const Target* target) const;
-
-  ImmutableVectorView<std::string> all_frameworks(const Target* target) const;
-
-  ImmutableVectorView<std::string> all_weak_frameworks(
-      const Target* target) const;
-
-  // Retrieve a set of hard dependencies for this target.
-  TargetSet recursive_hard_deps(const Target* target) const;
-
-  // Retrieve an ordered list of (target, is_public) pairs for all link-time
-  // libraries inherited by this target.
-  TargetPublicPairList inherited_libraries(const Target* target) const;
-
-  // Retrieves an ordered list of (target, is_public) paris for all link-time
-  // libraries for Rust-specific binary targets.
-  TargetPublicPairList rust_transitive_inherited_libs(
-      const Target* target) const;
-
- private:
-  class Impl;
-
-  Impl* GetImpl() const;
-
-  mutable std::unique_ptr<Impl> impl_;
-};
-
-#endif  // TOOLS_GN_RESOLVED_TARGET_DATA_H_
diff --git a/src/gn/resolved_target_data_unittest.cc b/src/gn/resolved_target_data_unittest.cc
deleted file mode 100644
index 1dd4d5a..0000000
--- a/src/gn/resolved_target_data_unittest.cc
+++ /dev/null
@@ -1,308 +0,0 @@
-// Copyright 2022 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 "gn/resolved_target_data.h"
-
-#include "gn/test_with_scope.h"
-#include "util/test/test.h"
-
-// Tests that lib[_dir]s are inherited across deps boundaries for static
-// libraries but not executables.
-TEST(ResolvedTargetDataTest, LibInheritance) {
-  TestWithScope setup;
-  Err err;
-
-  ResolvedTargetData resolved;
-
-  const LibFile lib("foo");
-  const SourceDir libdir("/foo_dir/");
-
-  // Leaf target with ldflags set.
-  TestTarget z(setup, "//foo:z", Target::STATIC_LIBRARY);
-  z.config_values().libs().push_back(lib);
-  z.config_values().lib_dirs().push_back(libdir);
-  ASSERT_TRUE(z.OnResolved(&err));
-
-  // All lib[_dir]s should be set when target is resolved.
-  auto z_info = resolved.GetLibInfo(&z);
-  ASSERT_EQ(1u, z_info.all_libs.size());
-  EXPECT_EQ(lib, z_info.all_libs[0]);
-  ASSERT_EQ(1u, z_info.all_lib_dirs.size());
-  EXPECT_EQ(libdir, z_info.all_lib_dirs[0]);
-
-  // Shared library target should inherit the libs from the static library
-  // and its own. Its own flag should be before the inherited one.
-  const LibFile second_lib("bar");
-  const SourceDir second_libdir("/bar_dir/");
-  TestTarget shared(setup, "//foo:shared", Target::SHARED_LIBRARY);
-  shared.config_values().libs().push_back(second_lib);
-  shared.config_values().lib_dirs().push_back(second_libdir);
-  shared.private_deps().push_back(LabelTargetPair(&z));
-  ASSERT_TRUE(shared.OnResolved(&err));
-
-  const auto libinfo = resolved.GetLibInfo(&shared);
-  ASSERT_EQ(2u, libinfo.all_libs.size());
-  EXPECT_EQ(second_lib, libinfo.all_libs[0]);
-  EXPECT_EQ(lib, libinfo.all_libs[1]);
-  ASSERT_EQ(2u, libinfo.all_lib_dirs.size());
-  EXPECT_EQ(second_libdir, libinfo.all_lib_dirs[0]);
-  EXPECT_EQ(libdir, libinfo.all_lib_dirs[1]);
-
-  // Executable target shouldn't get either by depending on shared.
-  TestTarget exec(setup, "//foo:exec", Target::EXECUTABLE);
-  exec.private_deps().push_back(LabelTargetPair(&shared));
-  ASSERT_TRUE(exec.OnResolved(&err));
-  auto exec_libinfo = resolved.GetLibInfo(&exec);
-  EXPECT_EQ(0u, exec_libinfo.all_libs.size());
-  EXPECT_EQ(0u, exec_libinfo.all_lib_dirs.size());
-}
-
-// Tests that framework[_dir]s are inherited across deps boundaries for static
-// libraries but not executables.
-TEST(ResolvedTargetDataTest, FrameworkInheritance) {
-  TestWithScope setup;
-  Err err;
-
-  const std::string framework("Foo.framework");
-  const SourceDir frameworkdir("//out/foo/");
-
-  // Leaf target with ldflags set.
-  TestTarget z(setup, "//foo:z", Target::STATIC_LIBRARY);
-  z.config_values().frameworks().push_back(framework);
-  z.config_values().framework_dirs().push_back(frameworkdir);
-  ASSERT_TRUE(z.OnResolved(&err));
-
-  ResolvedTargetData resolved;
-
-  // All framework[_dir]s should be set when target is resolved.
-  auto info = resolved.GetFrameworkInfo(&z);
-  ASSERT_EQ(1u, info.all_frameworks.size());
-  EXPECT_EQ(framework, info.all_frameworks[0]);
-  ASSERT_EQ(1u, info.all_framework_dirs.size());
-  EXPECT_EQ(frameworkdir, info.all_framework_dirs[0]);
-
-  // Shared library target should inherit the libs from the static library
-  // and its own. Its own flag should be before the inherited one.
-  const std::string second_framework("Bar.framework");
-  const SourceDir second_frameworkdir("//out/bar/");
-  TestTarget shared(setup, "//foo:shared", Target::SHARED_LIBRARY);
-  shared.config_values().frameworks().push_back(second_framework);
-  shared.config_values().framework_dirs().push_back(second_frameworkdir);
-  shared.private_deps().push_back(LabelTargetPair(&z));
-  ASSERT_TRUE(shared.OnResolved(&err));
-
-  auto shared_info = resolved.GetFrameworkInfo(&shared);
-  ASSERT_EQ(2u, shared_info.all_frameworks.size());
-  EXPECT_EQ(second_framework, shared_info.all_frameworks[0]);
-  EXPECT_EQ(framework, shared_info.all_frameworks[1]);
-  ASSERT_EQ(2u, shared_info.all_framework_dirs.size());
-  EXPECT_EQ(second_frameworkdir, shared_info.all_framework_dirs[0]);
-  EXPECT_EQ(frameworkdir, shared_info.all_framework_dirs[1]);
-
-  // Executable target shouldn't get either by depending on shared.
-  TestTarget exec(setup, "//foo:exec", Target::EXECUTABLE);
-  exec.private_deps().push_back(LabelTargetPair(&shared));
-  ASSERT_TRUE(exec.OnResolved(&err));
-  auto exec_info = resolved.GetFrameworkInfo(&exec);
-  EXPECT_EQ(0u, exec_info.all_frameworks.size());
-  EXPECT_EQ(0u, exec_info.all_framework_dirs.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.
-  auto c_inherited_libs = resolved.inherited_libraries(&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.
-  auto b_inherited = resolved.inherited_libraries(&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).
-  auto a_inherited = resolved.inherited_libraries(&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.inherited_libraries(&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.
-  auto b_inherited = resolved.inherited_libraries(&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).
-  auto a_inherited = resolved.inherited_libraries(&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.
-  auto a_info = resolved.GetLibInfo(&a);
-  ASSERT_EQ(1u, a_info.all_libs.size());
-  EXPECT_EQ(lib, a_info.all_libs[0]);
-  ASSERT_EQ(1u, a_info.all_lib_dirs.size());
-  EXPECT_EQ(lib_dir, a_info.all_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.
-  auto b_inherited = resolved.inherited_libraries(&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).
-  auto a_inherited = resolved.inherited_libraries(&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.
-  auto b_inherited = resolved.inherited_libraries(&b);
-  ASSERT_EQ(1u, b_inherited.size());
-  EXPECT_EQ(&c, b_inherited[0].target());
-
-  // A should have B and C in its inherited libs.
-  auto a_inherited = resolved.inherited_libraries(&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.
-    auto libs = resolved.inherited_libraries(&a);
-    ASSERT_TRUE(libs.empty());
-  }
-}
diff --git a/src/gn/resolved_target_deps.h b/src/gn/resolved_target_deps.h
deleted file mode 100644
index 5d3903a..0000000
--- a/src/gn/resolved_target_deps.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2022 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.
-
-#ifndef TOOLS_GN_RESOLVED_TARGET_DEPS_H_
-#define TOOLS_GN_RESOLVED_TARGET_DEPS_H_
-
-#include "base/containers/span.h"
-#include "gn/label_ptr.h"
-
-#include <memory>
-
-// A class used to record the dependencies of a given Target in
-// a way that is much more efficient to iterate over than having three
-// separate LabelTargetVector instances. Technically equivalent to
-// DepsIterator, but profiling shows that this class is much faster
-// to use during graph-traversal heavy operations.
-//
-// Usage is:
-//   1) Create instance, passing const references to the LabelTargetVector
-//      instances for the private, public and data deps for the target.
-//
-//   2) Use private_deps(), public_deps(), data_deps(), linked_deps()
-//      and all_deps() to retrieve spans that cover various subsets of
-//      interests. These can be used directly in for-range loops as in:
-//
-//       for (const Target* target : resolved.linked_deps()) {
-//         ..
-//       }
-//
-class ResolvedTargetDeps {
- public:
-  ResolvedTargetDeps() = default;
-
-  ResolvedTargetDeps(const LabelTargetVector& public_deps,
-                     const LabelTargetVector& private_deps,
-                     const LabelTargetVector& data_deps)
-      : public_count_(static_cast<uint32_t>(public_deps.size())),
-        private_count_(static_cast<uint32_t>(private_deps.size())),
-        data_count_(static_cast<uint32_t>(data_deps.size())),
-        deps_(Allocate(public_deps, private_deps, data_deps)) {}
-
-  size_t size() const { return private_count_ + public_count_ + data_count_; }
-
-  base::span<const Target*> public_deps() const {
-    return {deps_.get(), public_count_};
-  }
-
-  base::span<const Target*> private_deps() const {
-    return {deps_.get() + public_count_, private_count_};
-  }
-
-  base::span<const Target*> data_deps() const {
-    return {deps_.get() + private_count_ + public_count_, data_count_};
-  }
-
-  base::span<const Target*> linked_deps() const {
-    return {deps_.get(), private_count_ + public_count_};
-  }
-
-  base::span<const Target*> all_deps() const {
-    return {deps_.get(), private_count_ + public_count_ + data_count_};
-  }
-
-  static std::unique_ptr<const Target* []> Allocate(
-      const LabelTargetVector& public_deps,
-      const LabelTargetVector& private_deps,
-      const LabelTargetVector& data_deps) {
-    size_t total_size =
-        private_deps.size() + public_deps.size() + data_deps.size();
-    auto result = std::make_unique<const Target*[]>(total_size);
-    const Target** ptr = result.get();
-    for (const auto& pair : public_deps)
-      *ptr++ = pair.ptr;
-    for (const auto& pair : private_deps)
-      *ptr++ = pair.ptr;
-    for (const auto& pair : data_deps)
-      *ptr++ = pair.ptr;
-    return result;
-  }
-
-  private : uint32_t public_count_ = 0;
-  uint32_t private_count_ = 0;
-  uint32_t data_count_ = 0;
-  std::unique_ptr<const Target*[]> deps_;
-};
-
-#endif  // TOOLS_GN_RESOLVED_TARGET_DEPS_H_
diff --git a/src/gn/resolved_target_deps_unittest.cc b/src/gn/resolved_target_deps_unittest.cc
deleted file mode 100644
index 74d623d..0000000
--- a/src/gn/resolved_target_deps_unittest.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2022 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 "gn/resolved_target_deps.h"
-#include "gn/test_with_scope.h"
-#include "util/test/test.h"
-
-TEST(ResolvedTargetDeps, DefaultConstruction) {
-  ResolvedTargetDeps deps;
-  EXPECT_EQ(0u, deps.size());
-  EXPECT_TRUE(deps.public_deps().empty());
-  EXPECT_TRUE(deps.private_deps().empty());
-  EXPECT_TRUE(deps.data_deps().empty());
-  EXPECT_TRUE(deps.linked_deps().empty());
-  EXPECT_TRUE(deps.all_deps().empty());
-}
-
-TEST(ResolvedTargetDeps, Construction) {
-  TestWithScope setup;
-  TestTarget a(setup, "//foo:a", Target::STATIC_LIBRARY);
-  TestTarget b(setup, "//foo:b", Target::SOURCE_SET);
-  TestTarget c(setup, "//foo:c", Target::SOURCE_SET);
-  TestTarget d(setup, "//foo:d", Target::SOURCE_SET);
-  TestTarget e(setup, "//foo:e", Target::EXECUTABLE);
-
-  LabelTargetVector public_vec;
-  LabelTargetVector private_vec;
-  LabelTargetVector data_vec;
-
-  public_vec.emplace_back(&a);
-  public_vec.emplace_back(&b);
-  private_vec.emplace_back(&c);
-  private_vec.emplace_back(&d);
-  data_vec.emplace_back(&e);
-
-  ResolvedTargetDeps deps(public_vec, private_vec, data_vec);
-  EXPECT_EQ(5u, deps.size());
-
-  EXPECT_EQ(2u, deps.public_deps().size());
-  EXPECT_EQ(&a, deps.public_deps()[0]);
-  EXPECT_EQ(&b, deps.public_deps()[1]);
-
-  EXPECT_EQ(2u, deps.private_deps().size());
-  EXPECT_EQ(&c, deps.private_deps()[0]);
-  EXPECT_EQ(&d, deps.private_deps()[1]);
-
-  EXPECT_EQ(1u, deps.data_deps().size());
-  EXPECT_EQ(&e, deps.data_deps()[0]);
-
-  EXPECT_EQ(4u, deps.linked_deps().size());
-  EXPECT_EQ(&a, deps.linked_deps()[0]);
-  EXPECT_EQ(&b, deps.linked_deps()[1]);
-  EXPECT_EQ(&c, deps.linked_deps()[2]);
-  EXPECT_EQ(&d, deps.linked_deps()[3]);
-
-  EXPECT_EQ(5u, deps.all_deps().size());
-  EXPECT_EQ(&a, deps.all_deps()[0]);
-  EXPECT_EQ(&b, deps.all_deps()[1]);
-  EXPECT_EQ(&c, deps.all_deps()[2]);
-  EXPECT_EQ(&d, deps.all_deps()[3]);
-  EXPECT_EQ(&e, deps.all_deps()[4]);
-}
diff --git a/src/gn/tagged_pointer.h b/src/gn/tagged_pointer.h
deleted file mode 100644
index df760d1..0000000
--- a/src/gn/tagged_pointer.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2022 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.
-
-#ifndef TOOLS_GN_TAGGED_POINTER_H_
-#define TOOLS_GN_TAGGED_POINTER_H_
-
-#include "base/logging.h"
-
-// A TaggedPointer<T.N> is a compact encoding of a (pointer, tag) pair
-// when all |tag| values are guaranteed to be less than N bits long, and
-// all pointer values are guaranteed to be aligned to at least N bits.
-template <typename T, size_t BITS>
-class TaggedPointer {
- public:
-  TaggedPointer() = default;
-  TaggedPointer(T* ptr, unsigned tag)
-      : value_(reinterpret_cast<uintptr_t>(ptr)) {
-    CheckPointerValue(ptr);
-    CheckTagValue(tag);
-    value_ |= static_cast<uintptr_t>(tag);
-  }
-
-  T* ptr() const { return reinterpret_cast<T*>(value_ & ~kTagMask); }
-  unsigned tag() const { return static_cast<unsigned>(value_ & kTagMask); }
-
-  void set_ptr(T* ptr) {
-    CheckPointerValue(ptr);
-    value_ = reinterpret_cast<uintptr_t>(ptr) | (value_ & kTagMask);
-  }
-
-  void set_tag(unsigned tag) {
-    CheckTagValue(tag);
-    value_ = (value_ & ~kTagMask) | tag;
-  }
-
-  bool operator==(TaggedPointer other) const { return value_ == other.value_; }
-
-  bool operator!=(TaggedPointer other) const { return !(*this == other); }
-
-  bool operator<(TaggedPointer other) const { return value_ < other.value_; }
-
- private:
-  static const uintptr_t kTagMask = (uintptr_t(1) << BITS) - 1u;
-
-  static void CheckPointerValue(T* ptr) {
-    DCHECK((reinterpret_cast<uintptr_t>(ptr) & kTagMask) == 0)
-        << "Pointer is not aligned to " << BITS << " bits: " << ptr;
-  }
-  static void CheckTagValue(unsigned tag) {
-    DCHECK(tag <= kTagMask)
-        << "Tag value is larger than " << BITS << " bits: " << tag;
-  }
-
-  uintptr_t value_ = 0;
-};
-
-#endif  // TOOLS_GN_TAGGED_POINTER_H_
diff --git a/src/gn/tagged_pointer_unittest.cc b/src/gn/tagged_pointer_unittest.cc
deleted file mode 100644
index b6d68e5..0000000
--- a/src/gn/tagged_pointer_unittest.cc
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "gn/tagged_pointer.h"
-#include "util/test/test.h"
-
-struct Point {
-  double x;
-  double y;
-};
-
-TEST(TaggedPointer, Creation) {
-  TaggedPointer<Point, 2> ptr;
-
-  EXPECT_FALSE(ptr.ptr());
-  EXPECT_EQ(0u, ptr.tag());
-
-  Point point1 = {1., 2.};
-  TaggedPointer<Point, 2> ptr2(&point1, 2);
-  EXPECT_EQ(&point1, ptr2.ptr());
-  EXPECT_EQ(2u, ptr2.tag());
-}
diff --git a/src/gn/target_public_pair.h b/src/gn/target_public_pair.h
deleted file mode 100644
index c8ff655..0000000
--- a/src/gn/target_public_pair.h
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2022 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.
-
-#ifndef TOOLS_GN_TARGET_PUBLIC_PAIR_H_
-#define TOOLS_GN_TARGET_PUBLIC_PAIR_H_
-
-#include "gn/immutable_vector.h"
-#include "gn/tagged_pointer.h"
-#include "gn/unique_vector.h"
-
-class Target;
-
-// A Compact encoding for a (target_ptr, is_public_flag) pair.
-class TargetPublicPair {
- public:
-  TargetPublicPair() = default;
-  TargetPublicPair(const Target* target, bool is_public)
-      : pair_(target, static_cast<unsigned>(is_public)) {}
-  TargetPublicPair(std::pair<const Target*, bool> pair)
-      : pair_(pair.first, static_cast<unsigned>(pair.second)) {}
-
-  const Target* target() const { return pair_.ptr(); }
-  void set_target(const Target* target) { pair_.set_ptr(target); }
-
-  bool is_public() const { return pair_.tag() != 0; }
-  void set_is_public(bool is_public) { pair_.set_tag(is_public ? 1 : 0); }
-
-  // Utility structs that can be used to instantiante containers
-  // that only use the target for lookups / comparisons. E.g.
-  //
-  //   std::unordered_set<TargetPublicPair,
-  //                      TargetPublicPair::TargetHash,
-  //                      TargetPublicPair::TargetEqualTo>
-  //
-  //   std::set<TargetPublicPair, TargetPublicPair::TargetLess>
-  //
-  struct TargetHash {
-    size_t operator()(TargetPublicPair p) const noexcept {
-      return std::hash<const Target*>()(p.target());
-    }
-  };
-
-  struct TargetEqualTo {
-    bool operator()(TargetPublicPair a, TargetPublicPair b) const noexcept {
-      return a.target() == b.target();
-    }
-  };
-
-  struct TargetLess {
-    bool operator()(TargetPublicPair a, TargetPublicPair b) const noexcept {
-      return a.target() < b.target();
-    }
-  };
-
- private:
-  TaggedPointer<const Target, 1> pair_;
-};
-
-// A helper type to build a list of (target, is_public) pairs, where target
-// pointers are unique. Usage is:
-//
-//   1) Create builder instance.
-//   2) Call Append() or AppendInherited() as many times as necessary.
-//   3) Call Build() to retrieve final list as an immutable vector.
-//
-class TargetPublicPairListBuilder
-    : public UniqueVector<TargetPublicPair,
-                          TargetPublicPair::TargetHash,
-                          TargetPublicPair::TargetEqualTo> {
- public:
-  // Add (target, is_public) to the list being constructed. If the target
-  // was not already in the list, recorded the |is_public| flag as is,
-  // otherwise, set the recorded flag to true only if |is_public| is true, or
-  // don't do anything otherwise.
-  void Append(const Target* target, bool is_public) {
-    auto ret = EmplaceBackWithIndex(target, is_public);
-    if (!ret.first && is_public) {
-      // UniqueVector<T>::operator[]() always returns a const reference
-      // because the returned values are lookup keys in its set-like data
-      // structure (thus modifying them would break its internal consistency).
-      // However, because TargetHash and TargetEqualTo are being used to
-      // instantiate this template, only the target() part of the value must
-      // remain constant, and it is possible to modify the is_public() part
-      // in-place safely.
-      auto* pair = const_cast<TargetPublicPair*>(&(*this)[ret.second]);
-      pair->set_is_public(true);
-    }
-  }
-
-  // Append all pairs from any container with begin() and end() iterators
-  // that dereference to values that convert to a TargetPublicPair value.
-  // If |is_public| is false, the input pair will be appended with the
-  // value of the public flag to false.
-  template <
-      typename C,
-      typename = std::void_t<
-          decltype(static_cast<TargetPublicPair>(*std::declval<C>().begin())),
-          decltype(static_cast<TargetPublicPair>(*std::declval<C>().end()))>>
-  void AppendInherited(const C& other, bool is_public) {
-    for (const auto& pair : other) {
-      Append(pair.target(), is_public && pair.is_public());
-    }
-  }
-
-  ImmutableVector<TargetPublicPair> Build() {
-    return ImmutableVector<TargetPublicPair>(release());
-  }
-};
-
-#endif  // TOOLS_GN_TARGET_PUBLIC_PAIR_H_
diff --git a/src/gn/target_public_pair_unittest.cc b/src/gn/target_public_pair_unittest.cc
deleted file mode 100644
index 8b08a0c..0000000
--- a/src/gn/target_public_pair_unittest.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2022 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 "gn/target_public_pair.h"
-#include "util/test/test.h"
-
-TEST(TargetPublicPairTest, ConstructionAndMutation) {
-  // Fake target pointer values.
-  const auto* a_target = reinterpret_cast<const Target*>(1000);
-  const auto* b_target = reinterpret_cast<const Target*>(2000);
-
-  TargetPublicPair a_pair(a_target, true);
-  EXPECT_EQ(a_target, a_pair.target());
-  EXPECT_TRUE(a_pair.is_public());
-
-  TargetPublicPair b_pair(b_target, false);
-  EXPECT_EQ(b_target, b_pair.target());
-  EXPECT_FALSE(b_pair.is_public());
-
-  a_pair.set_target(b_target);
-  EXPECT_EQ(b_target, a_pair.target());
-  EXPECT_TRUE(a_pair.is_public());
-
-  a_pair.set_is_public(false);
-  EXPECT_EQ(b_target, a_pair.target());
-  EXPECT_FALSE(a_pair.is_public());
-
-  a_pair = TargetPublicPair(a_target, true);
-  EXPECT_EQ(a_target, a_pair.target());
-  EXPECT_TRUE(a_pair.is_public());
-
-  b_pair = std::move(a_pair);
-  EXPECT_EQ(a_target, b_pair.target());
-  EXPECT_TRUE(b_pair.is_public());
-}
-
-TEST(TargetPublicPairTest, Builder) {
-  const auto* a_target = reinterpret_cast<const Target*>(1000);
-  const auto* b_target = reinterpret_cast<const Target*>(2000);
-  TargetPublicPairListBuilder builder;
-
-  builder.Append(a_target, false);
-  builder.Append(b_target, false);
-  builder.Append(a_target, true);
-  builder.Append(b_target, false);
-
-  auto list = builder.Build();
-  EXPECT_EQ(2u, list.size());
-  EXPECT_EQ(a_target, list[0].target());
-  EXPECT_EQ(b_target, list[1].target());
-  EXPECT_TRUE(list[0].is_public());
-  EXPECT_FALSE(list[1].is_public());
-}
diff --git a/src/util/aligned_alloc.h b/src/util/aligned_alloc.h
deleted file mode 100644
index 99ecd29..0000000
--- a/src/util/aligned_alloc.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2022 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.
-
-#ifndef TOOLS_UTIL_ALIGNED_ALLOC_H_
-#define TOOLS_UTIL_ALIGNED_ALLOC_H_
-
-#ifdef __APPLE__
-#include <Availability.h>
-#endif
-
-#include <cstdlib>
-
-#define IMPL_ALIGNED_ALLOC_CXX17 1
-#define IMPL_ALIGNED_ALLOC_WIN32 2
-#define IMPL_ALIGNED_ALLOC_POSIX 3
-
-#ifndef IMPL_ALIGNED_ALLOC
-#ifdef _WIN32
-#define IMPL_ALIGNED_ALLOC IMPL_ALIGNED_ALLOC_WIN32
-#elif defined(__APPLE__)
-// Note that aligned_alloc() is only available at runtime starting from
-// OSX 10.15, so use posix_memalign() instead which is more portable.
-#define IMPL_ALIGNED_ALLOC IMPL_ALIGNED_ALLOC_POSIX
-#else
-#define IMPL_ALIGNED_ALLOC IMPL_ALIGNED_ALLOC_CXX17
-#endif
-#endif
-
-#if IMPL_ALIGNED_ALLOC == IMPL_ALIGNED_ALLOC_WIN32
-#include <malloc.h>  // for _aligned_malloc() and _aligned_free()
-#endif
-
-#if IMPL_ALIGNED_ALLOC == IMPL_ALIGNED_ALLOC_POSIX
-#include "base/logging.h"  // for CHECK()
-#endif
-
-// AlignedAlloc<N> provides Alloc() and Free() methods that can be
-// used to allocate and release blocks of heap memory aligned with
-// N bytes.
-//
-// The implementation uses std::aligned_alloc() when it is available,
-// or uses fallbacks otherwise. On Win32, _aligned_malloc() and
-// _aligned_free() are used, while for MacOS releases, ::posix_memaloc()
-// is used.
-template <size_t ALIGNMENT>
-struct AlignedAlloc {
-  static void* Alloc(size_t size) {
-    static_assert((ALIGNMENT & (ALIGNMENT - 1)) == 0,
-                  "ALIGNMENT must be a power of 2");
-#if IMPL_ALIGNED_ALLOC == IMPL_ALIGNED_ALLOC_WIN32
-    return _aligned_malloc(size, ALIGNMENT);
-#elif IMPL_ALIGNED_ALLOC == IMPL_ALIGNED_ALLOC_POSIX
-    void* ptr = nullptr;
-    CHECK(!posix_memalign(&ptr, ALIGNMENT, size));
-    return ptr;
-#else  // IMPL_ALIGNED_ALLOC_CXX17
-    return std::aligned_alloc(ALIGNMENT, size);
-#endif
-  }
-
-  static void Free(void* block) {
-#if IMPL_ALIGNED_ALLOC == IMPL_ALIGNED_ALLOC_WIN32
-    _aligned_free(block);
-#elif IMPL_ALIGNED_ALLOC == IMPL_ALIGNED_ALLOC_POSIX
-    return ::free(block);
-#else
-    // Allocation came from std::aligned_alloc()
-    return std::free(block);
-#endif
-  }
-};
-
-#endif  // TOOLS_UTIL_ALIGNED_ALLOC_H_
diff --git a/src/util/aligned_alloc_unittest.cc b/src/util/aligned_alloc_unittest.cc
deleted file mode 100644
index d41a775..0000000
--- a/src/util/aligned_alloc_unittest.cc
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2022 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 "util/aligned_alloc.h"
-#include "util/test/test.h"
-
-using AlignedAllocPtrSize = AlignedAlloc<sizeof(void*)>;
-using AlignedAlloc32 = AlignedAlloc<32>;
-
-TEST(AlignedAllocTest, PtrSized) {
-  void* ptr = AlignedAllocPtrSize::Alloc(2 * sizeof(void*));
-  ASSERT_TRUE(ptr);
-  ASSERT_EQ(reinterpret_cast<uintptr_t>(ptr) % sizeof(void*), 0u);
-  AlignedAllocPtrSize::Free(ptr);
-}
-
-TEST(AlignedAllocTest, Align32) {
-  void* ptr = AlignedAlloc32::Alloc(64);
-  ASSERT_TRUE(ptr);
-  ASSERT_EQ(reinterpret_cast<uintptr_t>(ptr) % 32u, 0u);
-  AlignedAlloc32::Free(ptr);
-}