diff --git a/libcxx/docs/OneRangesProposalStatus.csv b/libcxx/docs/OneRangesProposalStatus.csv
--- a/libcxx/docs/OneRangesProposalStatus.csv
+++ b/libcxx/docs/OneRangesProposalStatus.csv
@@ -137,7 +137,7 @@
 `[range.all] <http://wg21.link/range.all>`_,`view::all <https://llvm.org/D102028>`_,"[range.subrange], [range.view.ref]",Zoe Carver,In progress
 `[range.view.ref] <http://wg21.link/range.view>`_,`ref-view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,In progress
 `[range.filter] <http://wg21.link/range.filter>`_,filter_view,[range.all],Louis Dionne,Not started
-`[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,In progress
+`[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
 `[range.iota] <http://wg21.link/range.iota>`_,iota_view,[range.all],Louis Dionne,Not started
 `[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,Not started
 `[range.join] <http://wg21.link/range.join>`_,join_view,[range.all],Christopher Di Bella,Not started
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -149,10 +149,11 @@
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
-  __ranges/view_interface.h
   __ranges/ref_view.h
   __ranges/size.h
   __ranges/subrange.h
+  __ranges/transform_view.h
+  __ranges/view_interface.h
   __split_buffer
   __std_stream
   __string
diff --git a/libcxx/include/__ranges/concepts.h b/libcxx/include/__ranges/concepts.h
--- a/libcxx/include/__ranges/concepts.h
+++ b/libcxx/include/__ranges/concepts.h
@@ -112,6 +112,9 @@
 
   template <class _Tp>
   concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp> >;
+
+  template<bool _Const, class _Tp>
+  using __maybe_const = conditional_t<_Const, const _Tp, _Tp>;
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
diff --git a/libcxx/include/__ranges/copyable_box.h b/libcxx/include/__ranges/copyable_box.h
--- a/libcxx/include/__ranges/copyable_box.h
+++ b/libcxx/include/__ranges/copyable_box.h
@@ -86,8 +86,8 @@
       return *this;
     }
 
-    constexpr _Tp const& operator*() const { return *__val_; }
-    constexpr _Tp& operator*() { return *__val_; }
+    constexpr _Tp const& operator*() const noexcept { return *__val_; }
+    constexpr _Tp& operator*() noexcept { return *__val_; }
     constexpr explicit operator bool() const noexcept { return static_cast<bool>(__val_); }
   };
 
@@ -140,8 +140,8 @@
       return *this;
     }
 
-    constexpr _Tp const& operator*() const { return __val_; }
-    constexpr _Tp& operator*() { return __val_; }
+    constexpr _Tp const& operator*() const noexcept { return __val_; }
+    constexpr _Tp& operator*() noexcept { return __val_; }
     constexpr explicit operator bool() const noexcept { return true; }
   };
 } // namespace ranges
diff --git a/libcxx/include/__ranges/transform_view.h b/libcxx/include/__ranges/transform_view.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/transform_view.h
@@ -0,0 +1,357 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___RANGES_TRANSFORM_VIEW_H
+#define _LIBCPP___RANGES_TRANSFORM_VIEW_H
+
+#include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/concepts.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/copyable_box.h>
+#include <__ranges/empty.h>
+#include <__ranges/view_interface.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+// REVIEW-NOTE: This is *not* part of the transform_view patch and will be added by a *separate* PR.
+template<class _I1, class _I2 = _I1>
+concept indirectly_swappable =
+    indirectly_readable<_I1> &&
+    indirectly_readable<_I2> &&
+    requires(const _I1 i1, const _I2 i2) {
+        ranges::iter_swap(i1, i1);
+        ranges::iter_swap(i1, i2);
+        ranges::iter_swap(i2, i1);
+        ranges::iter_swap(i2, i2);
+    };
+// END-REVIEW-NOTE.
+
+namespace ranges {
+
+template<class _View, class _Fn>
+concept __transform_view_constraints =
+           view<_View> && is_object_v<_Fn> &&
+           regular_invocable<_Fn&, range_reference_t<_View>> &&
+           __referenceable<invoke_result_t<_Fn&, range_reference_t<_View>>>;
+
+template<input_range _View, copy_constructible _Fn>
+  requires __transform_view_constraints<_View, _Fn>
+class transform_view : public view_interface<transform_view<_View, _Fn>> {
+  template<bool> class __iterator;
+  template<bool> class __sentinel;
+
+  _View __base_ = _View();
+  __copyable_box<_Fn> __func_;
+
+public:
+  transform_view()
+    requires default_initializable<_View> && default_initializable<_Fn> = default;
+
+  constexpr transform_view(_View __base, _Fn __func)
+    : __base_(_VSTD::move(__base)), __func_(_VSTD::in_place, _VSTD::move(__func)) {}
+
+  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  constexpr _View base() && { return _VSTD::move(__base_); }
+
+  constexpr __iterator<false> begin() {
+    return __iterator<false>{*this, ranges::begin(__base_)};
+  }
+  constexpr __iterator<true> begin() const
+    requires range<const _View> &&
+             regular_invocable<const _Fn&, range_reference_t<const _View>>
+  {
+    return __iterator<true>{*this, ranges::begin(__base_)};
+  }
+
+  constexpr __sentinel<false> end() {
+    return __sentinel<false>{ranges::end(__base_)};
+  }
+  constexpr __iterator<false> end()
+    requires common_range<_View>
+  {
+    return __iterator<false>{*this, ranges::end(__base_)};
+  }
+  constexpr __sentinel<true> end() const
+    requires range<const _View> &&
+             regular_invocable<const _Fn&, range_reference_t<const _View>>
+  {
+    return __sentinel<true>{ranges::end(__base_)};
+  }
+  constexpr __iterator<true> end() const
+    requires common_range<const _View> &&
+             regular_invocable<const _Fn&, range_reference_t<const _View>>
+  {
+    return __iterator<true>{*this, ranges::end(__base_)};
+  }
+
+  constexpr auto size() requires sized_range<_View> { return ranges::size(__base_); }
+  constexpr auto size() const requires sized_range<const _View> { return ranges::size(__base_); }
+};
+
+// TODO: replace the decltype with all_t when that's implemented.
+template<class _Range, class _Fn>
+transform_view(_Range&&, _Fn)
+  -> transform_view<decltype(views::all(std::declval<_Range>())), _Fn>;
+
+template<class _View>
+struct __transform_view_iterator_concept { using type = input_iterator_tag; };
+
+template<random_access_range _View>
+struct __transform_view_iterator_concept<_View> { using type = random_access_iterator_tag; };
+
+template<bidirectional_range _View>
+struct __transform_view_iterator_concept<_View> { using type = bidirectional_iterator_tag; };
+
+template<forward_range _View>
+struct __transform_view_iterator_concept<_View> { using type = forward_iterator_tag; };
+
+template<class, class>
+struct __iterator_category_base {};
+
+template<forward_range _View, class _Fn>
+struct __iterator_category_base<_View, _Fn> {
+  using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
+
+  using iterator_category = conditional_t<
+    is_lvalue_reference_v<invoke_result_t<_Fn&, range_reference_t<_View>>>,
+    conditional_t<
+      derived_from<_Cat, contiguous_iterator_tag>,
+      random_access_iterator_tag,
+      _Cat
+    >,
+    input_iterator_tag
+  >;
+};
+
+template<input_range _View, copy_constructible _Fn>
+  requires __transform_view_constraints<_View, _Fn>
+template<bool _Const>
+class transform_view<_View, _Fn>::__iterator
+  : public __iterator_category_base<_View, _Fn> {
+
+  using _Parent = __maybe_const<_Const, transform_view>;
+  using _Base = __maybe_const<_Const, _View>;
+
+  iterator_t<_Base> __current_ = iterator_t<_Base>();
+  _Parent *__parent_ = nullptr;
+
+  template<bool>
+  friend class transform_view<_View, _Fn>::__sentinel;
+
+public:
+  using iterator_concept = typename __transform_view_iterator_concept<_View>::type;
+  using value_type = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
+  using difference_type = range_difference_t<_Base>;
+
+  __iterator() = default;
+
+  constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
+    : __current_(_VSTD::move(__current)), __parent_(_VSTD::addressof(__parent)) {}
+  constexpr __iterator(__iterator<false> __i)
+    requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+    : __current_(_VSTD::move(__i.__current_)), __parent_(__i.__parent_) {}
+
+  constexpr iterator_t<_Base> base() const&
+    requires copyable<iterator_t<_Base>>
+  {
+    return __current_;
+  }
+  constexpr iterator_t<_Base> base() && {
+    return _VSTD::move(__current_);
+  }
+
+  constexpr decltype(auto) operator*() const
+    noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, *__current_)))
+  {
+    return _VSTD::invoke(*__parent_->__func_, *__current_);
+  }
+
+  constexpr __iterator& operator++() {
+    ++__current_;
+    return *this;
+  }
+  constexpr void        operator++(int) { ++__current_; }
+  constexpr __iterator  operator++(int)
+    requires forward_range<_Base>
+  {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  constexpr __iterator& operator--()
+    requires bidirectional_range<_Base>
+  {
+    --__current_;
+    return *this;
+  }
+  constexpr __iterator  operator--(int)
+    requires bidirectional_range<_Base>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  constexpr __iterator& operator+=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ += __n;
+    return *this;
+  }
+  constexpr __iterator& operator-=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ -= __n;
+    return *this;
+  }
+  constexpr decltype(auto) operator[](difference_type __n) const
+    noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, __current_[__n])))
+    requires random_access_range<_Base>
+  {
+    return _VSTD::invoke(*__parent_->__func_, __current_[__n]);
+  }
+
+  friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+    requires equality_comparable<iterator_t<_Base>>
+  {
+    return __x.__current_ == __y.__current_;
+  }
+
+  friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ < __y.__current_;
+  }
+  friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ > __y.__current_;
+  }
+  friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ <= __y.__current_;
+  }
+  friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ >= __y.__current_;
+  }
+//   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_;
+//   }
+
+  friend constexpr __iterator operator+(__iterator __i, difference_type __n)
+    requires random_access_range<_Base>
+  {
+    return __iterator{*__i.__parent_, __i.__current_ + __n};
+  }
+  friend constexpr __iterator operator+(difference_type __n, __iterator __i)
+    requires random_access_range<_Base>
+  {
+    return __iterator{*__i.__parent_, __i.__current_ + __n};
+  }
+
+  friend constexpr __iterator operator-(__iterator __i, difference_type __n)
+    requires random_access_range<_Base>
+  {
+    return __iterator{*__i.__parent_, __i.__current_ - __n};
+  }
+  friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+    requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+  {
+    return __x.__current_ - __y.__current_;
+  }
+
+  friend constexpr decltype(auto) iter_move(const __iterator& __i)
+    noexcept(noexcept(*__i))
+  {
+    if constexpr (is_lvalue_reference_v<decltype(*__i)>)
+      return _VSTD::move(*__i);
+    else
+      return *__i;
+  }
+
+  friend constexpr void iter_swap(const __iterator& __x, const __iterator& __y)
+    noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
+    requires indirectly_swappable<iterator_t<_Base>>
+  {
+    ranges::iter_swap(__x.__current_, __y.__current_);
+  }
+};
+
+template<input_range _View, copy_constructible _Fn>
+  requires __transform_view_constraints<_View, _Fn>
+template<bool _Const>
+class transform_view<_View, _Fn>::__sentinel {
+  using _Parent = __maybe_const<_Const, transform_view>;
+  using _Base = __maybe_const<_Const, _View>;
+
+  sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+  template<bool>
+  friend class transform_view<_View, _Fn>::__iterator;
+
+  template<bool>
+  friend class transform_view<_View, _Fn>::__sentinel;
+
+public:
+  __sentinel() = default;
+
+  constexpr explicit __sentinel(sentinel_t<_Base> __end_) : __end_(__end_) {}
+  constexpr __sentinel(__sentinel<false> __i)
+    requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+    : __end_(_VSTD::move(__i.__end_)) {}
+
+  constexpr sentinel_t<_Base> base() const { return __end_; }
+
+  template<bool _OtherConst>
+    requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __x.__current_ == __y.__end_;
+  }
+
+  template<bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __x.__current_ - __y.__end_;
+  }
+
+  template<bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
+    return __x.__end_ - __y.__current_;
+  }
+};
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H
diff --git a/libcxx/include/optional b/libcxx/include/optional
--- a/libcxx/include/optional
+++ b/libcxx/include/optional
@@ -906,7 +906,7 @@
     _LIBCPP_INLINE_VISIBILITY
     constexpr
     const value_type&
-    operator*() const&
+    operator*() const& noexcept
     {
         _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
         return this->__get();
@@ -915,7 +915,7 @@
     _LIBCPP_INLINE_VISIBILITY
     constexpr
     value_type&
-    operator*() &
+    operator*() & noexcept
     {
         _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
         return this->__get();
@@ -924,7 +924,7 @@
     _LIBCPP_INLINE_VISIBILITY
     constexpr
     value_type&&
-    operator*() &&
+    operator*() && noexcept
     {
         _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
         return _VSTD::move(this->__get());
@@ -933,7 +933,7 @@
     _LIBCPP_INLINE_VISIBILITY
     constexpr
     const value_type&&
-    operator*() const&&
+    operator*() const&& noexcept
     {
         _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
         return _VSTD::move(this->__get());
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -101,6 +101,14 @@
 
   template<class T>
     inline constexpr bool enable_borrowed_range<drop_view<T>> = enable_borrowed_range<T>;
+
+  // [range.transform], transform view
+  template<input_range V, copy_constructible F>
+    requires view<V> && is_object_v<F> &&
+             regular_invocable<F&, range_reference_t<V>> &&
+             can-reference<invoke_result_t<F&, range_reference_t<V>>>
+  class transform_view;
+
 }
 
 */
@@ -118,6 +126,7 @@
 #include <__ranges/ref_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
+#include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/base.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/base.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr V base() const& requires copy_constructible<V>
+// constexpr V base() &&
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view<ContiguousView, Increment> transformView;
+    ContiguousView base = std::move(transformView).base();
+    ASSERT_SAME_TYPE(ContiguousView, decltype(std::move(transformView).base()));
+    assert(std::ranges::begin(base) == globalBuff);
+  }
+
+  {
+    std::ranges::transform_view<CopyableView, Increment> transformView;
+    CopyableView base1 = transformView.base();
+    ASSERT_SAME_TYPE(CopyableView, decltype(transformView.base()));
+    assert(std::ranges::begin(base1) == globalBuff);
+
+    CopyableView base2 = std::move(transformView).base();
+    ASSERT_SAME_TYPE(CopyableView, decltype(std::move(transformView).base()));
+    assert(std::ranges::begin(base2) == globalBuff);
+  }
+
+  {
+    const std::ranges::transform_view<CopyableView, Increment> transformView;
+    const CopyableView base1 = transformView.base();
+    ASSERT_SAME_TYPE(CopyableView, decltype(transformView.base()));
+    assert(std::ranges::begin(base1) == globalBuff);
+
+    const CopyableView base2 = std::move(transformView).base();
+    ASSERT_SAME_TYPE(CopyableView, decltype(std::move(transformView).base()));
+    assert(std::ranges::begin(base2) == globalBuff);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/begin.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/begin.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr iterator<false> begin();
+// constexpr iterator<true> begin() const
+//   requires range<const V> &&
+//            regular_invocable<const F&, range_reference_t<const V>>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept BeginInvocable = requires(T t) { t.begin(); };
+
+constexpr bool test() {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+  {
+    std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+    assert(transformView.begin().base() == buff);
+    assert(*transformView.begin() == 1);
+  }
+
+  {
+    std::ranges::transform_view transformView(ForwardView{buff}, Increment{});
+    assert(transformView.begin().base().base() == buff);
+    assert(*transformView.begin() == 1);
+  }
+
+  {
+    std::ranges::transform_view transformView(InputView{buff}, Increment{});
+    assert(transformView.begin().base().base() == buff);
+    assert(*transformView.begin() == 1);
+  }
+
+  {
+    const std::ranges::transform_view transformView(ContiguousView{buff}, IncrementConst{});
+    assert(*transformView.begin() == 1);
+  }
+
+  static_assert(!BeginInvocable<const std::ranges::transform_view<ContiguousView, Increment>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/ctad.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/ctad.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/ctad.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// CTAD tests.
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+static_assert(std::same_as<decltype(std::ranges::transform_view(InputView(), Increment())),
+                           std::ranges::transform_view<InputView, Increment>>);
+static_assert(std::same_as<decltype(std::ranges::transform_view(std::declval<ForwardRange&>(), Increment())),
+                           std::ranges::transform_view<std::ranges::ref_view<ForwardRange>, Increment>>);
+static_assert(std::same_as<decltype(std::ranges::transform_view(BorrowableRange(), Increment())),
+                           std::ranges::transform_view<std::ranges::subrange<int*>, Increment>>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr sentinel<false> end();
+// constexpr iterator<false> end() requires common_range<V>;
+// constexpr sentinel<true> end() const
+//   requires range<const V> &&
+//            regular_invocable<const F&, range_reference_t<const V>>;
+// constexpr iterator<true> end() const
+//   requires common_range<const V> &&
+//            regular_invocable<const F&, range_reference_t<const V>>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept EndInvocable = requires(T t) { t.end(); };
+
+template<class T>
+concept EndIsIter = requires(T t) { ++t.end(); };
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view transformView(ContiguousView{}, Increment{});
+    assert(transformView.end().base() == globalBuff + 8);
+  }
+
+  {
+    std::ranges::transform_view transformView(ForwardView{}, Increment{});
+    assert(transformView.end().base().base() == globalBuff + 8);
+  }
+
+  {
+    std::ranges::transform_view transformView(InputView{}, Increment{});
+    assert(transformView.end().base() == globalBuff + 8);
+  }
+
+  {
+    const std::ranges::transform_view transformView(ContiguousView{}, IncrementConst{});
+    assert(transformView.end().base() == globalBuff + 8);
+  }
+
+  static_assert(!EndInvocable<const std::ranges::transform_view<ContiguousView, Increment>>);
+  static_assert( EndInvocable<      std::ranges::transform_view<ContiguousView, Increment>>);
+  static_assert( EndInvocable<const std::ranges::transform_view<ContiguousView, IncrementConst>>);
+  static_assert(!EndInvocable<const std::ranges::transform_view<InputView, Increment>>);
+  static_assert( EndInvocable<      std::ranges::transform_view<InputView, Increment>>);
+  static_assert( EndInvocable<const std::ranges::transform_view<InputView, IncrementConst>>);
+
+  static_assert(!EndIsIter<const std::ranges::transform_view<InputView, IncrementConst>>);
+  static_assert(!EndIsIter<      std::ranges::transform_view<InputView, Increment>>);
+  static_assert( EndIsIter<const std::ranges::transform_view<ContiguousView, IncrementConst>>);
+  static_assert( EndIsIter<      std::ranges::transform_view<ContiguousView, Increment>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp
@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// Some basic examples of how transform_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <ranges>
+
+#include <vector>
+#include <list>
+#include <numeric>
+#include <string>
+#include <cctype>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "types.h"
+
+template<std::ranges::range R>
+auto toUpper(R range) {
+  return std::ranges::transform_view(range, [](char c) { return std::toupper(c); });
+}
+
+unsigned badRandom() { return 42; }
+
+template<std::ranges::range R, class Fn = std::plus<std::iter_value_t<R>>>
+auto withRandom(R range, Fn func = Fn()) {
+  return std::ranges::transform_view(range, std::bind_front(func, badRandom()));
+}
+
+template<class E1, class E2, size_t N, class Join = std::plus<E1>>
+auto joinArrays(E1 (&a)[N], E2 (&b)[N], Join join = Join()) {
+  return std::ranges::transform_view(a, [&a, &b, join](auto& x) {
+    auto idx = (&x) - a;
+    return join(x, b[idx]);
+  });
+}
+
+template<>
+constexpr bool std::ranges::enable_view<std::vector<int>> = true;
+
+template<>
+constexpr bool std::ranges::enable_view<std::string_view> = true;
+
+int main(int, char**) {
+  {
+    std::vector vec = {1,2,3,4};
+    auto sortOfRandom = withRandom(vec);
+    std::vector check = {43, 44, 45, 46};
+    assert(std::equal(sortOfRandom.begin(), sortOfRandom.end(), check.begin(), check.end()));
+  }
+
+  {
+    int a[4] = {1, 2, 3, 4};
+    int b[4] = {4, 3, 2, 1};
+    auto out = joinArrays(a, b);
+    int check[4] = {5, 5, 5, 5};
+    assert(std::equal(out.begin(), out.end(), check));
+  }
+
+  {
+    std::string_view str = "Hello, World.";
+    auto upp = toUpper(str);
+    std::string_view check = "HELLO, WORLD.";
+    assert(std::equal(upp.begin(), upp.end(), check.begin(), check.end()));
+  }
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/arithmetic.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/arithmetic.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/arithmetic.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator{++,--,+=,-=}
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  std::ranges::transform_view<ContiguousView, Increment> transformView;
+  auto iter = std::move(transformView).begin();
+  assert((++iter).base() == globalBuff + 1);
+
+  assert((iter++).base() == globalBuff + 1);
+  assert(iter.base() == globalBuff + 2);
+
+  assert((--iter).base() == globalBuff + 1);
+  assert((iter--).base() == globalBuff + 1);
+  assert(iter.base() == globalBuff);
+
+  // Check that decltype(InputIter++) == void.
+  ASSERT_SAME_TYPE(decltype(
+    std::declval<std::ranges::iterator_t<std::ranges::transform_view<InputView, Increment>>>()++),
+    void);
+
+  assert((iter += 4).base() == globalBuff + 4);
+  assert((iter -= 3).base() == globalBuff + 1);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp
@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::base
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class V, class F>
+concept BaseInvocable = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter.base();
+};
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view<ContiguousView, Increment> transformView;
+    auto iter = std::move(transformView).begin();
+    ASSERT_SAME_TYPE(int*, decltype(iter.base()));
+    assert(iter.base() == globalBuff);
+    ASSERT_SAME_TYPE(int*, decltype(std::move(iter).base()));
+    assert(std::move(iter).base() == globalBuff);
+  }
+
+  {
+    std::ranges::transform_view<InputView, Increment> transformView;
+    auto iter = transformView.begin();
+    assert(std::move(iter).base() == globalBuff);
+    ASSERT_SAME_TYPE(cpp20_input_iterator<int *>, decltype(std::move(iter).base()));
+  }
+
+  static_assert(!BaseInvocable<InputView, Increment>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
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
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/compare.pass.cpp
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator{<,>,<=,>=}
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  std::ranges::transform_view<ContiguousView, Increment> transformView1;
+  auto iter1 = std::move(transformView1).begin();
+  std::ranges::transform_view<ContiguousView, Increment> transformView2;
+  auto iter2 = std::move(transformView2).begin();
+  assert(iter1 == iter2);
+  assert(iter1 + 1 != iter2);
+  assert(iter1 + 1 == iter2 + 1);
+
+  assert(iter1 < iter1 + 1);
+  assert(iter1 + 1 > iter1);
+  assert(iter1 <= iter1 + 1);
+  assert(iter1 <= iter2);
+  assert(iter1 + 1 >= iter2);
+  assert(iter1     >= iter2);
+  // TODO: operator<=> when three_way_comparable is implemented.
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/deref.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/deref.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/deref.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator*
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int main(int, char**) {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+  {
+    std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+    assert(*transformView.begin() == 1);
+  }
+
+  static_assert(!noexcept(
+    *std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>>()));
+  static_assert( noexcept(
+    *std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>>()));
+
+  ASSERT_SAME_TYPE(
+    int,
+    decltype(*std::declval<std::ranges::transform_view<RandomAccessView, Increment>>().begin()));
+  ASSERT_SAME_TYPE(
+    int&,
+    decltype(*std::declval<std::ranges::transform_view<RandomAccessView, IncrementRef>>().begin()));
+  ASSERT_SAME_TYPE(
+    int&&,
+    decltype(*std::declval<std::ranges::transform_view<RandomAccessView, IncrementRvalueRef>>().begin()));
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_move.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_move.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_move.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator[]
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+  {
+    std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+    auto iter = transformView.begin();
+    static_assert(!noexcept(std::ranges::iter_move(iter)));
+
+    assert(std::ranges::iter_move(iter) == 1);
+    assert(std::ranges::iter_move(iter + 2) == 3);
+
+    ASSERT_SAME_TYPE(int, decltype(std::ranges::iter_move(iter)));
+    ASSERT_SAME_TYPE(int, decltype(std::ranges::iter_move(std::move(iter))));
+  }
+
+  {
+    static_assert( noexcept(std::ranges::iter_move(
+      std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>&>())));
+    static_assert(!noexcept(std::ranges::iter_move(
+      std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>&>())));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_swap.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_swap.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_swap.pass.cpp
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::iter_swap
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+  std::ranges::transform_view transformView1(ContiguousView{buff}, Increment{});
+  auto iter1 = std::move(transformView1).begin();
+  std::ranges::transform_view transformView2(ContiguousView{buff}, Increment{});
+  auto iter2 = std::move(transformView2).begin();
+  iter1 += 4;
+  std::ranges::iter_swap(iter1, iter2);
+  assert(*iter1 == 1);
+  assert(*(buff + 4) == 0);
+  assert(*iter2 == 5);
+  assert(*buff == 4);
+  assert(*transformView1.begin() == 5);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_minus.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_minus.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_minus.pass.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator{+,-}
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  std::ranges::transform_view<ContiguousView, Increment> transformView1;
+  auto iter1 = std::move(transformView1).begin();
+  std::ranges::transform_view<ContiguousView, Increment> transformView2;
+  auto iter2 = std::move(transformView2).begin();
+  iter1 += 4;
+  assert((iter1 + 1).base() == globalBuff + 5);
+  assert((1 + iter1).base() == globalBuff + 5);
+  assert((iter1 - 1).base() == globalBuff + 3);
+  assert(iter1 - iter2 == 4);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp
@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// The requirements for transform_view::<iterator>'s members.
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class V, class F>
+concept IterMinusMinus = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter--;
+};
+static_assert(IterMinusMinus<BidirectionalView, IncrementConst>);
+static_assert(!IterMinusMinus<ForwardView, IncrementConst>);
+
+template<class V, class F>
+concept MinusMinusIter = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  --iter;
+};
+static_assert(MinusMinusIter<BidirectionalView, IncrementConst>);
+static_assert(!MinusMinusIter<ForwardView, IncrementConst>);
+
+template<class V, class F>
+concept IterPlusEquals = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter += 1;
+};
+static_assert(IterPlusEquals<RandomAccessView, IncrementConst>);
+static_assert(!IterPlusEquals<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterMinusEquals = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter -= 1;
+};
+static_assert(IterMinusEquals<RandomAccessView, IncrementConst>);
+static_assert(!IterMinusEquals<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterSubscript = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter[1];
+};
+static_assert(IterSubscript<RandomAccessView, IncrementConst>);
+static_assert(!IterSubscript<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterLess = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter < iter;
+};
+static_assert(IterLess<RandomAccessView, IncrementConst>);
+static_assert(!IterLess<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterGreater = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter > iter;
+};
+static_assert(IterGreater<RandomAccessView, IncrementConst>);
+static_assert(!IterGreater<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterLessEq = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter <= iter;
+};
+static_assert(IterLessEq<RandomAccessView, IncrementConst>);
+static_assert(!IterLessEq<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterGreaterEq = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter >= iter;
+};
+static_assert(IterGreaterEq<RandomAccessView, IncrementConst>);
+static_assert(!IterGreaterEq<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterPlusN = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter + 1;
+};
+static_assert(IterPlusN<RandomAccessView, IncrementConst>);
+static_assert(!IterPlusN<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept NPlusIter = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  std::declval<typename decltype(iter)::difference_type>() + iter;
+};
+static_assert(NPlusIter<RandomAccessView, IncrementConst>);
+static_assert(!NPlusIter<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterMinusN = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter - 1;
+};
+static_assert(IterMinusN<RandomAccessView, IncrementConst>);
+static_assert(!IterMinusN<BidirectionalView, IncrementConst>);
+
+template<class V, class F>
+concept IterMinusIter = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter - iter;
+};
+static_assert(IterMinusIter<RandomAccessView, IncrementConst>);
+static_assert(!IterMinusIter<BidirectionalView, IncrementConst>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/sentinel.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/sentinel.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/sentinel.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// class transform_view::<sentinel>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class T>
+concept EndIsIter = requires(T t) { ++t.end(); };
+
+constexpr bool test() {
+  std::ranges::transform_view<SizedSentinelView, IncrementConst> transformView1;
+  // Going to const and back.
+  auto sent1 = transformView1.end();
+  std::ranges::sentinel_t<const std::ranges::transform_view<SizedSentinelView, IncrementConst>> sent2{sent1};
+  std::ranges::sentinel_t<const std::ranges::transform_view<SizedSentinelView, IncrementConst>> sent3{sent2};
+  (void)sent3;
+
+  static_assert(!EndIsIter<decltype(sent1)>);
+  static_assert(!EndIsIter<decltype(sent2)>);
+  assert(sent1.base() == globalBuff + 8);
+
+  std::ranges::transform_view transformView2(SizedSentinelView{4}, IncrementConst());
+  auto sent4 = transformView2.end();
+  auto iter = transformView1.begin();
+  {
+    assert(iter != sent1);
+    assert(iter != sent2);
+    assert(iter != sent4);
+  }
+
+  {
+    assert(iter + 8 == sent1);
+    assert(iter + 8 == sent2);
+    assert(iter + 4 == sent4);
+  }
+
+  {
+    assert(sent1 - iter  == 8);
+    assert(sent4 - iter  == 4);
+    assert(iter  - sent1 == -8);
+    assert(iter  - sent4 == -4);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/subscript.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/subscript.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/subscript.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator[]
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+  std::ranges::transform_view transformView1(ContiguousView{buff}, Increment{});
+  auto iter1 = std::move(transformView1).begin() + 1;
+  assert(iter1[0] == 2);
+  assert(iter1[4] == 6);
+
+  static_assert(!noexcept(
+    std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>>()[0]));
+  static_assert( noexcept(
+    std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>>()[0]));
+
+  ASSERT_SAME_TYPE(
+    int,
+    decltype(std::declval<std::ranges::transform_view<RandomAccessView, Increment>>().begin()[0]));
+  ASSERT_SAME_TYPE(
+    int&,
+    decltype(std::declval<std::ranges::transform_view<RandomAccessView, IncrementRef>>().begin()[0]));
+  ASSERT_SAME_TYPE(
+    int&&,
+    decltype(std::declval<std::ranges::transform_view<RandomAccessView, IncrementRvalueRef>>().begin()[0]));
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::difference_type
+// transform_view::<iterator>::value_type
+// transform_view::<iterator>::iterator_category
+// transform_view::<iterator>::iterator_concept
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class V, class F>
+concept HasIterConcept = requires { typename std::ranges::transform_view<V, F>::iterator_category; };
+
+constexpr bool test() {
+  {
+    // Member typedefs for contiguous iterator.
+    static_assert(std::same_as<std::iterator_traits<int*>::iterator_concept, std::contiguous_iterator_tag>);
+    static_assert(std::same_as<std::iterator_traits<int*>::iterator_category, std::random_access_iterator_tag>);
+
+    using TView = std::ranges::transform_view<ContiguousView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for random access iterator.
+    using TView = std::ranges::transform_view<RandomAccessView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for random access iterator/not-lvalue-ref.
+    using TView = std::ranges::transform_view<RandomAccessView, Increment>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::input_iterator_tag>); // Note: this is now input_iterator_tag.
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for bidirectional iterator.
+    using TView = std::ranges::transform_view<BidirectionalView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::bidirectional_iterator_tag>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for forward iterator.
+    using TView = std::ranges::transform_view<ForwardView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for input iterator.
+    using TView = std::ranges::transform_view<InputView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::input_iterator_tag>);
+    static_assert(!HasIterConcept<InputView, IncrementRef>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto size() requires sized_range<V>
+// constexpr auto size() const requires sized_range<const V>
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept SizeInvocable = requires(T t) { t.size(); };
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view transformView(ContiguousView{}, Increment{});
+    assert(transformView.size() == 8);
+  }
+
+  {
+    const std::ranges::transform_view transformView(ContiguousView{globalBuff, 4}, Increment{});
+    assert(transformView.size() == 4);
+  }
+
+  static_assert(!SizeInvocable<std::ranges::transform_view<ForwardView, Increment>>);
+
+  static_assert(SizeInvocable<std::ranges::transform_view<SizedSentinelNotConstView, Increment>>);
+  static_assert(!SizeInvocable<const std::ranges::transform_view<SizedSentinelNotConstView, Increment>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/types.h b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
@@ -0,0 +1,147 @@
+#ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+int globalBuff[8] = {0,1,2,3,4,5,6,7};
+
+template<class T, class F>
+concept ValidDropView = requires { typename std::ranges::transform_view<T, F>; };
+
+struct ContiguousView : std::ranges::view_base {
+  int start;
+  int *ptr;
+  constexpr ContiguousView(int* ptr = globalBuff, int start = 0) : start(start), ptr(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr + view.start; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr + view.start; }
+  constexpr friend int* end(ContiguousView& view) { return view.ptr + 8; }
+  constexpr friend int* end(ContiguousView const& view) { return view.ptr + 8; }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int start;
+  constexpr CopyableView(int start = 0) : start(start) {}
+  constexpr CopyableView(CopyableView const&) = default;
+  constexpr CopyableView& operator=(CopyableView const&) = default;
+  constexpr friend int* begin(CopyableView& view) { return globalBuff + view.start; }
+  constexpr friend int* begin(CopyableView const& view) { return globalBuff + view.start; }
+  constexpr friend int* end(CopyableView&) { return globalBuff + 8; }
+  constexpr friend int* end(CopyableView const&) { return globalBuff + 8; }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct ForwardView : std::ranges::view_base {
+  int *ptr;
+  constexpr ForwardView(int* ptr = globalBuff) : ptr(ptr) {}
+  constexpr ForwardView(ForwardView&&) = default;
+  constexpr ForwardView& operator=(ForwardView&&) = default;
+  constexpr friend ForwardIter begin(ForwardView& view) { return ForwardIter(view.ptr); }
+  constexpr friend ForwardIter begin(ForwardView const& view) { return ForwardIter(view.ptr); }
+  constexpr friend ForwardIter end(ForwardView& view) { return ForwardIter(view.ptr + 8); }
+  constexpr friend ForwardIter end(ForwardView const& view) { return ForwardIter(view.ptr + 8); }
+};
+
+using ForwardRange = test_common_range<forward_iterator>;
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct RandomAccessView : std::ranges::view_base {
+  RandomAccessIter begin() const noexcept;
+  RandomAccessIter end() const noexcept;
+  RandomAccessIter begin() noexcept;
+  RandomAccessIter end() noexcept;
+};
+
+using BidirectionalIter = bidirectional_iterator<int*>;
+struct BidirectionalView : std::ranges::view_base {
+  BidirectionalIter begin() const;
+  BidirectionalIter end() const;
+  BidirectionalIter begin();
+  BidirectionalIter end();
+};
+
+struct BorrowableRange {
+  friend int* begin(BorrowableRange const& range);
+  friend int* end(BorrowableRange const&);
+  friend int* begin(BorrowableRange& range);
+  friend int* end(BorrowableRange&);
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
+
+struct InputView : std::ranges::view_base {
+  int *ptr;
+  constexpr InputView(int* ptr = globalBuff) : ptr(ptr) {}
+  constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(ptr); }
+  constexpr int* end() const { return ptr + 8; }
+  constexpr cpp20_input_iterator<int*> begin() { return cpp20_input_iterator<int*>(ptr); }
+  constexpr int* end() { return ptr + 8; }
+};
+
+constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+
+struct SizedSentinelView : std::ranges::view_base {
+  int count;
+  constexpr SizedSentinelView(int count = 8) : count(count) {}
+  constexpr RandomAccessIter begin() const { return RandomAccessIter(globalBuff); }
+  constexpr int* end() const { return globalBuff + count; }
+  constexpr RandomAccessIter begin() { return RandomAccessIter(globalBuff); }
+  constexpr int* end() { return globalBuff + count; }
+};
+
+constexpr long operator- (const RandomAccessIter &lhs, int* rhs) { return lhs.base() - rhs; }
+constexpr long operator- (int* lhs, const RandomAccessIter &rhs) { return lhs - rhs.base(); }
+constexpr bool operator==(const RandomAccessIter &lhs, int* rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(int* lhs, const RandomAccessIter &rhs) { return rhs.base() == lhs; }
+
+struct SizedSentinelNotConstView : std::ranges::view_base {
+  ForwardIter begin() const;
+  int *end() const;
+  ForwardIter begin();
+  int *end();
+  size_t size();
+};
+bool operator==(const ForwardIter &lhs, int* rhs);
+bool operator==(int* lhs, const ForwardIter &rhs);
+
+struct Range {
+  friend int* begin(Range const&);
+  friend int* end(Range const&);
+  friend int* begin(Range&);
+  friend int* end(Range&);
+};
+
+using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
+struct CountedView : std::ranges::view_base {
+  constexpr CountedIter begin() { return CountedIter(ForwardIter(globalBuff)); }
+  constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
+  constexpr CountedIter end() { return CountedIter(ForwardIter(globalBuff + 8)); }
+  constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
+};
+
+struct Increment {
+  constexpr int operator()(int x) { return x + 1; }
+};
+
+struct IncrementConst {
+  constexpr int operator()(int x) const { return x + 1; }
+};
+
+struct IncrementRef {
+  constexpr int& operator()(int x) { return ++x; }
+};
+
+struct IncrementRvalueRef {
+  constexpr int&& operator()(int x) { return std::move(++x); }
+};
+
+struct IncrementNoexcept {
+  constexpr int operator()(int x) noexcept { return x + 1; }
+};
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
@@ -44,6 +44,7 @@
     {
         optional<X> opt; ((void)opt);
         ASSERT_SAME_TYPE(decltype(*opt), X&);
+        LIBCPP_STATIC_ASSERT(noexcept(*opt));
         // ASSERT_NOT_NOEXCEPT(*opt);
         // FIXME: This assertion fails with GCC because it can see that
         // (A) operator*() is constexpr, and
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
@@ -37,6 +37,7 @@
     {
         const optional<X> opt; ((void)opt);
         ASSERT_SAME_TYPE(decltype(*opt), X const&);
+        LIBCPP_STATIC_ASSERT(noexcept(*opt));
         // ASSERT_NOT_NOEXCEPT(*opt);
         // FIXME: This assertion fails with GCC because it can see that
         // (A) operator*() is constexpr, and
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
@@ -37,6 +37,7 @@
     {
         const optional<X> opt; ((void)opt);
         ASSERT_SAME_TYPE(decltype(*std::move(opt)), X const &&);
+        LIBCPP_STATIC_ASSERT(noexcept(*opt));
         // ASSERT_NOT_NOEXCEPT(*std::move(opt));
         // FIXME: This assertion fails with GCC because it can see that
         // (A) operator*() is constexpr, and
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
@@ -44,6 +44,7 @@
     {
         optional<X> opt; ((void)opt);
         ASSERT_SAME_TYPE(decltype(*std::move(opt)), X&&);
+        LIBCPP_STATIC_ASSERT(noexcept(*opt));
         // ASSERT_NOT_NOEXCEPT(*std::move(opt));
         // FIXME: This assertion fails with GCC because it can see that
         // (A) operator*() is constexpr, and