diff --git a/libcxx/include/__ranges/transform_view.h b/libcxx/include/__ranges/transform_view.h
--- a/libcxx/include/__ranges/transform_view.h
+++ b/libcxx/include/__ranges/transform_view.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___RANGES_TRANSFORM_VIEW_H
 
 #include <__config>
+#include <__compare/three_way_comparable.h>
 #include <__functional/bind_back.h>
 #include <__functional/invoke.h>
 #include <__iterator/concepts.h>
@@ -297,13 +298,14 @@
     return __x.__current_ >= __y.__current_;
   }
 
-// TODO: Fix this as soon as soon as three_way_comparable is implemented.
-//   _LIBCPP_HIDE_FROM_ABI
-//   friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
-//     requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
-//   {
-//     return __x.__current_ <=> __y.__current_;
-//   }
+#if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+  {
+    return __x.__current_ <=> __y.__current_;
+  }
+#endif // !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
 
   _LIBCPP_HIDE_FROM_ABI
   friend constexpr __iterator operator+(__iterator __i, difference_type __n)
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/compare.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/compare.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/compare.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/compare.pass.cpp
@@ -10,51 +10,59 @@
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// transform_view::<iterator>::operator{<,>,<=,>=}
+// transform_view::<iterator>::operator{<,>,<=,>=,==,!=,<=>}
 
 #include <ranges>
 #include <compare>
 
 #include "test_macros.h"
+#include "test_iterators.h"
 #include "../types.h"
 
 constexpr bool test() {
   {
-    std::ranges::transform_view<ContiguousView, PlusOne> transformView1;
-    auto iter1 = std::move(transformView1).begin();
-    std::ranges::transform_view<ContiguousView, PlusOne> transformView2;
-    auto iter2 = std::move(transformView2).begin();
-    assert(iter1 == iter2);
-    assert(iter1 + 1 != iter2);
-    assert(iter1 + 1 == iter2 + 1);
+    // Test a new-school iterator with operator<=>; the transform iterator should also have operator<=>.
+    using It = three_way_contiguous_iterator<int*>;
+    static_assert(std::three_way_comparable<It>);
+    using R = std::ranges::transform_view<std::ranges::subrange<It>, PlusOne>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
 
-    assert(iter1 < iter1 + 1);
-    assert(iter1 + 1 > iter1);
-    assert(iter1 <= iter1 + 1);
-    assert(iter1 <= iter2);
-    assert(iter1 + 1 >= iter2);
-    assert(iter1     >= iter2);
+    int a[] = {1,2,3};
+    R r = std::ranges::subrange<It>(It(a), It(a+3)) | std::views::transform(PlusOne());
+    auto iter1 = r.begin();
+    auto iter2 = iter1 + 1;
+
+    assert(!(iter1 < iter1));  assert(iter1 < iter2);     assert(!(iter2 < iter1));
+    assert(iter1 <= iter1);    assert(iter1 <= iter2);    assert(!(iter2 <= iter1));
+    assert(!(iter1 > iter1));  assert(!(iter1 > iter2));  assert(iter2 > iter1);
+    assert(iter1 >= iter1);    assert(!(iter1 >= iter2)); assert(iter2 >= iter1);
+    assert(iter1 == iter1);    assert(!(iter1 == iter2)); assert(iter2 == iter2);
+    assert(!(iter1 != iter1)); assert(iter1 != iter2);    assert(!(iter2 != iter2));
+
+    assert((iter1 <=> iter2) == std::strong_ordering::less);
+    assert((iter1 <=> iter1) == std::strong_ordering::equal);
+    assert((iter2 <=> iter1) == std::strong_ordering::greater);
   }
 
-// TODO: when three_way_comparable is implemented and std::is_eq is implemented,
-// uncomment this.
-//   {
-//     std::ranges::transform_view<ThreeWayCompView, PlusOne> transformView1;
-//     auto iter1 = transformView1.begin();
-//     std::ranges::transform_view<ThreeWayCompView, PlusOne> transformView2;
-//     auto iter2 = transformView2.begin();
-//
-//     assert(std::is_eq(iter1   <=> iter2));
-//     assert(std::is_lteq(iter1 <=> iter2));
-//     ++iter2;
-//     assert(std::is_neq(iter1  <=> iter2));
-//     assert(std::is_lt(iter1   <=> iter2));
-//     assert(std::is_gt(iter2   <=> iter1));
-//     assert(std::is_gteq(iter2 <=> iter1));
-//
-//     static_assert( std::three_way_comparable<std::iterator_t<std::ranges::transform_view<ThreeWayCompView, PlusOne>>>);
-//     static_assert(!std::three_way_comparable<std::iterator_t<std::ranges::transform_view<ContiguousView, PlusOne>>>);
-//   }
+  {
+    // Test an old-school iterator with no operator<=>; the transform iterator shouldn't have operator<=> either.
+    using It = random_access_iterator<int*>;
+    static_assert(!std::three_way_comparable<It>);
+    using R = std::ranges::transform_view<std::ranges::subrange<It>, PlusOne>;
+    static_assert(!std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    int a[] = {1,2,3};
+    R r = std::ranges::subrange<It>(It(a), It(a+3)) | std::views::transform(PlusOne());
+    auto iter1 = r.begin();
+    auto iter2 = iter1 + 1;
+
+    assert(!(iter1 < iter1));  assert(iter1 < iter2);     assert(!(iter2 < iter1));
+    assert(iter1 <= iter1);    assert(iter1 <= iter2);    assert(!(iter2 <= iter1));
+    assert(!(iter1 > iter1));  assert(!(iter1 > iter2));  assert(iter2 > iter1);
+    assert(iter1 >= iter1);    assert(!(iter1 >= iter2)); assert(iter2 >= iter1);
+    assert(iter1 == iter1);    assert(!(iter1 == iter2)); assert(iter2 == iter2);
+    assert(!(iter1 != iter1)); assert(iter1 != iter2);    assert(!(iter2 != iter2));
+  }
 
   return true;
 }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/types.h b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
--- a/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
@@ -129,14 +129,6 @@
   constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
 };
 
-using ThreeWayCompIter = three_way_contiguous_iterator<int*>;
-struct ThreeWayCompView : std::ranges::view_base {
-  constexpr ThreeWayCompIter begin() { return ThreeWayCompIter(globalBuff); }
-  constexpr ThreeWayCompIter begin() const { return ThreeWayCompIter(globalBuff); }
-  constexpr ThreeWayCompIter end() { return ThreeWayCompIter(globalBuff + 8); }
-  constexpr ThreeWayCompIter end() const { return ThreeWayCompIter(globalBuff + 8); }
-};
-
 struct TimesTwo {
   constexpr int operator()(int x) const { return x * 2; }
 };