diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -44,6 +44,7 @@
__ranges/enable_borrowed_range.h
__ranges/view.h
__ranges/size.h
+ __ranges/subrange.h
__ranges/view_interface.h
__split_buffer
__std_stream
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
@@ -68,6 +68,9 @@
bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp> >;
} // namespace ranges
+template<class _Tp, class _Up>
+concept __not_same_as = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
+
#endif // !defined(_LIBCPP_HAS_NO_RANGES)
// clang-format on
diff --git a/libcxx/include/__ranges/subrange.h b/libcxx/include/__ranges/subrange.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/subrange.h
@@ -0,0 +1,252 @@
+// -*- 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_SUBRANGE_H
+#define _LIBCPP___RANGES_SUBRANGE_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/primitives.h>
+#include <__ranges/access.h>
+#include <__ranges/enable_borrowed_range.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)
+
+// clang-format off
+namespace ranges {
+
+ template<class _Range>
+ concept borrowed_range =
+ range<_Range> &&
+ (is_lvalue_reference_v<_Range> || enable_borrowed_range<remove_cvref_t<_Range>>);
+
+ template<class _Range>
+ concept sized_range = range<_Range> && requires(_Range& t) {
+ ranges::size(t);
+ };
+
+ template<class _From, class _To>
+ concept __convertible_to_non_slicing =
+ convertible_to<_From, _To> &&
+ // If they're both pointers, they must have the same element type.
+ !(is_pointer_v<decay_t<_From>> &&
+ is_pointer_v<decay_t<_To>> &&
+ __not_same_as<remove_pointer_t<decay_t<_From>>, remove_pointer_t<decay_t<_To>>>);
+
+ template<class _Tp>
+ concept __pair_like =
+ !is_reference_v<_Tp> && requires(_Tp __t) {
+ typename tuple_size<_Tp>::type;
+ requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
+ typename tuple_element_t<0, remove_const_t<_Tp>>;
+ typename tuple_element_t<1, remove_const_t<_Tp>>;
+ { get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
+ { get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
+ };
+
+ template<class _Pair, class _Iter, class _Sent>
+ concept __pair_like_convertible_from =
+ !range<_Pair> && __pair_like<_Pair> &&
+ constructible_from<_Pair, _Iter, _Sent> &&
+ __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> &&
+ convertible_to<_Sent, tuple_element_t<1, _Pair>>;
+
+ enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized };
+
+ template<class _Iter, class _Sent, subrange_kind _Kind>
+ struct __subrange_base {
+ static constexpr bool __store_size = false;
+ _Iter __begin = _Iter();
+ _Sent __end = _Sent();
+
+ constexpr __subrange_base() = default;
+ constexpr __subrange_base(_Iter __iter, _Sent __sent)
+ : __begin(_VSTD::move(__iter)), __end(__sent) { }
+ };
+
+ template<class _Iter, class _Sent>
+ struct __subrange_base<_Iter, _Sent, subrange_kind::sized> {
+ static constexpr bool __store_size = true;
+ _Iter __begin = _Iter();
+ _Sent __end = _Sent();
+ make_unsigned_t<iter_difference_t<_Iter>> __size = 0;
+
+ constexpr __subrange_base() = default;
+ constexpr __subrange_base(_Iter __iter, _Sent __sent, decltype(__size) __size)
+ : __begin(_VSTD::move(__iter)), __end(__sent), __size(__size) { }
+ };
+
+ template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
+ subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter>
+ ? subrange_kind::sized
+ : subrange_kind::unsized>
+ requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
+ struct _LIBCPP_TEMPLATE_VIS subrange
+ : public view_interface<subrange<_Iter, _Sent, _Kind>>,
+ private __subrange_base<_Iter, _Sent, _Kind> {
+
+ constexpr subrange() = default;
+
+ using _Base = __subrange_base<_Iter, _Sent, _Kind>;
+ using _Base::__store_size;
+ using _Base::__begin;
+ using _Base::__end;
+
+ constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
+ requires (!__store_size)
+ : _Base(_VSTD::move(__iter), __sent) {}
+
+ constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent,
+ make_unsigned_t<iter_difference_t<_Iter>> __n)
+ requires (_Kind == subrange_kind::sized)
+ : _Base(_VSTD::move(__iter), __sent, __n) { }
+
+ template<__not_same_as<subrange> _Range>
+ requires borrowed_range<_Range> &&
+ __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+ convertible_to<sentinel_t<_Range>, _Sent>
+ constexpr subrange(_Range&& __range)
+ requires (!__store_size)
+ : subrange(ranges::begin(__range), ranges::end(__range)) { }
+
+ template<__not_same_as<subrange> _Range>
+ requires borrowed_range<_Range> &&
+ __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+ convertible_to<sentinel_t<_Range>, _Sent>
+ constexpr subrange(_Range&& __range)
+ requires sized_range<_Range>
+ : subrange(__range, ranges::size(__range)) { }
+
+
+ template<borrowed_range _Range>
+ requires __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+ convertible_to<sentinel_t<_Range>, _Sent>
+ constexpr subrange(_Range&& __range, make_unsigned_t<iter_difference_t<_Iter>> __n)
+ requires (_Kind == subrange_kind::sized)
+ : subrange(ranges::begin(__range), ranges::end(__range), __n) { }
+
+ template<class _Pair>
+ requires (!same_as<subrange, _Pair>) &&
+ __pair_like_convertible_from<_Pair, const _Iter&, const _Sent&>
+ constexpr operator _Pair() const { return _Pair(__begin, __end); }
+
+ constexpr _Iter begin() const requires copyable<_Iter> {
+ return __begin;
+ }
+
+ _LIBCPP_NODISCARD_EXT constexpr _Iter begin() requires (!copyable<_Iter>) {
+ return _VSTD::move(__begin);
+ }
+
+ constexpr _Sent end() const { return __end; }
+
+ _LIBCPP_NODISCARD_EXT constexpr bool empty() const { return __begin == __end; }
+
+ constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
+ requires (_Kind == subrange_kind::sized)
+ {
+ if constexpr (__store_size)
+ return _Base::__size;
+ else
+ return __to_unsigned_like(__end - __begin);
+ }
+
+ _LIBCPP_NODISCARD_EXT constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
+ requires forward_iterator<_Iter> {
+ auto __tmp = *this;
+ __tmp.advance(__n);
+ return __tmp;
+ }
+
+ _LIBCPP_NODISCARD_EXT constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
+ advance(__n);
+ return _VSTD::move(*this);
+ }
+
+ _LIBCPP_NODISCARD_EXT constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
+ requires bidirectional_iterator<_Iter> {
+ auto __tmp = *this;
+ __tmp.advance(-__n);
+ return __tmp;
+ }
+
+ constexpr subrange& advance(iter_difference_t<_Iter> __n) {
+ if constexpr (bidirectional_iterator<_Iter>) {
+ if (__n < 0) {
+ ranges::advance(__begin, __n);
+ if constexpr (__store_size)
+ _Base::__size += __to_unsigned_like(-__n);
+ return *this;
+ }
+ }
+
+ auto __d = __n - ranges::advance(__begin, __n, __end);
+ if constexpr (__store_size)
+ _Base::__size -= __to_unsigned_like(__d);
+ return *this;
+ }
+ };
+
+ template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+ subrange(_Iter, _Sent) -> subrange<_Iter, _Sent>;
+
+ template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+ subrange(_Iter, _Sent, make_unsigned_t<iter_difference_t<_Iter>>)
+ -> subrange<_Iter, _Sent, subrange_kind::sized>;
+
+ template<borrowed_range _Range>
+ subrange(_Range&&) -> subrange<iterator_t<_Range>, sentinel_t<_Range>,
+ (sized_range<_Range> || sized_sentinel_for<sentinel_t<_Range>, iterator_t<_Range>>)
+ ? subrange_kind::sized : subrange_kind::unsized>;
+
+ template<borrowed_range _Range>
+ subrange(_Range&&, make_unsigned_t<range_difference_t<_Range>>) ->
+ subrange<iterator_t<_Range>, sentinel_t<_Range>, subrange_kind::sized>;
+
+ template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+ requires (_Index < 2)
+ constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange) {
+ if constexpr (_Index == 0)
+ return __subrange.begin();
+ else
+ return __subrange.end();
+ }
+
+ template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+ requires (_Index < 2)
+ constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange) {
+ if constexpr (_Index == 0)
+ return __subrange.begin();
+ else
+ return __subrange.end();
+ }
+} // namespace ranges
+
+using ranges::get;
+
+// clang-format off
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_SUBRANGE_H
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -83,6 +83,7 @@
#include <__ranges/enable_borrowed_range.h>
#include <__ranges/view.h>
#include <__ranges/size.h>
+#include <__ranges/subrange.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.utility/range.subrange/access.pass.cpp b/libcxx/test/std/ranges/range.utility/range.subrange/access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.utility/range.subrange/access.pass.cpp
@@ -0,0 +1,181 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// class std::ranges::subrange;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+namespace ranges = std::ranges;
+
+// Note: begin and end tested in range.subrange.ctor.pass.cpp.
+
+int globalBuff[8];
+
+struct MoveOnlyForwardIter {
+ typedef std::forward_iterator_tag iterator_category;
+ typedef int value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef int* pointer;
+ typedef int& reference;
+ typedef MoveOnlyForwardIter self;
+
+ int *base = nullptr;
+
+ MoveOnlyForwardIter() = default;
+ MoveOnlyForwardIter(MoveOnlyForwardIter &&) = default;
+ MoveOnlyForwardIter &operator=(MoveOnlyForwardIter&&) = default;
+ MoveOnlyForwardIter(MoveOnlyForwardIter const&) = delete;
+ constexpr MoveOnlyForwardIter(int *ptr) : base(ptr) { }
+
+ friend bool operator==(const self&, const self&);
+ constexpr friend bool operator==(const self& lhs, int* rhs) { return lhs.base == rhs; }
+
+ reference operator*() const;
+ pointer operator->() const;
+ self& operator++();
+ self operator++(int);
+ self& operator--();
+ self operator--(int);
+
+ constexpr operator pointer() const { return base; }
+};
+
+using ForwardIter = forward_iterator<int*>;
+
+using std::ptrdiff_t;
+struct SizedSentinelForwardIter {
+ typedef std::forward_iterator_tag iterator_category;
+ typedef int value_type;
+ typedef ptrdiff_t difference_type;
+ typedef int* pointer;
+ typedef int& reference;
+ typedef std::make_unsigned_t<ptrdiff_t> udifference_type;
+ typedef SizedSentinelForwardIter self;
+
+ int *base;
+
+ SizedSentinelForwardIter() = default;
+ constexpr SizedSentinelForwardIter(int *ptr) : base(ptr) { }
+
+ constexpr friend bool operator==(const self& lhs, const self& rhs) { return lhs.base == rhs.base; }
+
+ reference operator*() const;
+ pointer operator->() const;
+ self& operator++();
+ self operator++(int);
+ self& operator--();
+ self operator--(int);
+
+ constexpr friend difference_type operator-(SizedSentinelForwardIter const&a,
+ SizedSentinelForwardIter const&b) {
+ return a.base - b.base;
+ }
+};
+
+constexpr bool testPrimatives() {
+ ranges::subrange<MoveOnlyForwardIter, int*> a(MoveOnlyForwardIter(globalBuff), globalBuff + 8, 8);
+ assert(a.begin().base == globalBuff);
+ assert(!a.empty());
+ assert(a.size() == 8);
+
+ ranges::subrange<ForwardIter> b(ForwardIter(nullptr), ForwardIter(nullptr));
+ assert(b.empty());
+
+ ranges::subrange<ForwardIter> c{ForwardIter(globalBuff), ForwardIter(globalBuff)};
+ assert(c.empty());
+
+ ranges::subrange<ForwardIter> d(ForwardIter(globalBuff), ForwardIter(globalBuff + 1));
+ assert(!d.empty());
+
+ ranges::subrange<SizedSentinelForwardIter> e(SizedSentinelForwardIter(globalBuff),
+ SizedSentinelForwardIter(globalBuff + 8), 8);
+ assert(!e.empty());
+ assert(e.size() == 8);
+
+ return true;
+}
+
+using InputIter = cpp17_input_iterator<int*>;
+
+using BidirIter = bidirectional_iterator<int*>;
+
+constexpr bool testAdvance() {
+ ranges::subrange<int*> a(globalBuff, globalBuff + 8, 8);
+ auto a1 = a.next();
+ assert(a1.begin() == globalBuff + 1);
+ assert(a1.size() == 7);
+ auto a5 = a.next(5);
+ assert(a5.begin() == globalBuff + 5);
+ assert(a5.size() == 3);
+ auto a4 = a5.prev();
+ assert(a4.begin() == globalBuff + 4);
+ assert(a4.size() == 4);
+
+ ranges::subrange<InputIter> b(InputIter(globalBuff), InputIter(globalBuff + 8));
+ auto b1 = std::move(b).next();
+ assert(b1.begin().base() == globalBuff + 1);
+
+ ranges::subrange<BidirIter> c(BidirIter(globalBuff + 4), BidirIter(globalBuff + 8));
+ auto c1 = c.prev();
+ assert(c1.begin().base() == globalBuff + 3);
+ auto c2 = c.prev(4);
+ assert(c2.begin().base() == globalBuff);
+
+ ranges::subrange<BidirIter> d(BidirIter(globalBuff + 4), BidirIter(globalBuff + 8));
+ auto d1 = d.advance(4);
+ assert(d1.begin().base() == globalBuff + 8);
+ assert(d1.empty());
+ auto d2 = d1.advance(-4);
+ assert(d2.begin().base() == globalBuff + 4);
+
+ return true;
+}
+
+template<size_t I, class S>
+concept GetInvocable = requires {
+ std::get<I>(std::declval<S>());
+};
+
+static_assert( GetInvocable<0, ranges::subrange<int*>>);
+static_assert( GetInvocable<1, ranges::subrange<int*>>);
+static_assert(!GetInvocable<2, ranges::subrange<int*>>);
+static_assert(!GetInvocable<3, ranges::subrange<int*>>);
+
+constexpr bool testGet() {
+ ranges::subrange<int*> a(globalBuff, globalBuff + 8, 8);
+ assert(std::get<0>(a) == a.begin());
+ assert(std::get<1>(a) == a.end());
+
+ assert(a.begin() == std::get<0>(std::move(a)));
+ ranges::subrange<int*> b(globalBuff, globalBuff + 8, 8);
+ assert(b.end() == std::get<1>(std::move(b)));
+
+ return true;
+}
+
+int main(int, char**) {
+ testPrimatives();
+ static_assert(testPrimatives());
+
+ testAdvance();
+ static_assert(testAdvance());
+
+ testGet();
+ static_assert(testGet());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.utility/range.subrange/ctad.compile.pass.cpp b/libcxx/test/std/ranges/range.utility/range.subrange/ctad.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.utility/range.subrange/ctad.compile.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
+// XFAIL: msvc && clang
+
+// class std::ranges::subrange;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+using std::ranges::subrange;
+
+static_assert(std::same_as<decltype(subrange(forward_iterator<int*>(nullptr), forward_iterator<int*>(nullptr))), subrange<forward_iterator<int*>, forward_iterator<int*>, std::ranges::subrange_kind::unsized>>);
+static_assert(std::same_as<decltype(subrange(static_cast<int*>(nullptr), static_cast<int*>(nullptr), 0)), subrange<int*, int*, std::ranges::subrange_kind::sized>>);
+static_assert(std::same_as<decltype(subrange(static_cast<int*>(nullptr), nullptr, 0)), subrange<int*, nullptr_t, std::ranges::subrange_kind::sized>>);
+
+struct ForwardRange {
+ forward_iterator<int*> begin() const;
+ forward_iterator<int*> end() const;
+};
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<ForwardRange> = true;
+
+struct SizedRange {
+ int *begin();
+ int *end();
+};
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<SizedRange> = true;
+
+static_assert(std::same_as<decltype(subrange(ForwardRange())), subrange<forward_iterator<int*>, forward_iterator<int*>, std::ranges::subrange_kind::unsized>>);
+static_assert(std::same_as<decltype(subrange(SizedRange())), subrange<int*, int*, std::ranges::subrange_kind::sized>>);
+static_assert(std::same_as<decltype(subrange(SizedRange(), 8)), subrange<int*, int*, std::ranges::subrange_kind::sized>>);
diff --git a/libcxx/test/std/ranges/range.utility/range.subrange/ctor.pass.cpp b/libcxx/test/std/ranges/range.utility/range.subrange/ctor.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.utility/range.subrange/ctor.pass.cpp
@@ -0,0 +1,238 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// class std::ranges::subrange;
+
+#include <ranges>
+
+#include <cassert>
+#include <tuple>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+namespace ranges = std::ranges;
+
+// convertible-to-non-slicing cases:
+// 1. Not convertible (fail)
+// 2. Only one is a pointer (succeed)
+// 3. Both are not pointers (succeed)
+// 4. Pointer elements are different types (fail)
+// 5. Pointer elements are same type (succeed)
+
+int globalBuff[8];
+
+struct Empty {};
+
+using ForwardIter = forward_iterator<int*>;
+using FowardSubrange = ranges::subrange<ForwardIter, ForwardIter, std::ranges::subrange_kind::unsized>;
+
+static_assert(std::is_default_constructible_v<FowardSubrange>);
+
+struct ConvertibleForwardIter {
+ typedef std::forward_iterator_tag iterator_category;
+ typedef int value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef int* pointer;
+ typedef int& reference;
+ typedef ConvertibleForwardIter self;
+
+ int *base = nullptr;
+
+ constexpr ConvertibleForwardIter() = default;
+ constexpr explicit ConvertibleForwardIter(int *ptr) : base(ptr) { }
+
+ friend bool operator==(const self&, const self&);
+
+ reference operator*() const;
+ pointer operator->() const;
+ self& operator++();
+ self operator++(int);
+ self& operator--();
+ self operator--(int);
+
+ constexpr operator pointer() const { return base; }
+
+ // Explicitly deleted so this doesn't model sized_sentinel_for.
+ friend constexpr difference_type operator-(int *, self const&) = delete;
+ friend constexpr difference_type operator-(self const&, int*) = delete;
+};
+using ConvertibleFowardSubrange = ranges::subrange<ConvertibleForwardIter, int*,
+ std::ranges::subrange_kind::unsized>;
+static_assert(std::is_convertible_v<ConvertibleForwardIter, int*>);
+
+using std::ptrdiff_t;
+template<bool EnableConvertible>
+struct SizedSentinelForwardIterBase {
+ typedef std::forward_iterator_tag iterator_category;
+ typedef int value_type;
+ typedef ptrdiff_t difference_type;
+ typedef int* pointer;
+ typedef int& reference;
+ typedef std::make_unsigned_t<ptrdiff_t> udifference_type;
+ typedef SizedSentinelForwardIterBase self;
+
+ int *value = nullptr;
+
+ constexpr SizedSentinelForwardIterBase() = default;
+ constexpr explicit SizedSentinelForwardIterBase(int *ptr) : value(ptr) {}
+
+ constexpr int *base() const { return value; }
+
+ friend bool operator==(const self&, const self&);
+
+ reference operator*() const;
+ pointer operator->() const;
+ self& operator++();
+ self operator++(int);
+ self& operator--();
+ self operator--(int);
+
+ template<bool E = EnableConvertible>
+ requires E
+ constexpr operator pointer() const { return value; }
+};
+using SizedSentinelForwardIter = SizedSentinelForwardIterBase<false>;
+using SizedSentinelFowardSubrange = ranges::subrange<SizedSentinelForwardIter,
+ SizedSentinelForwardIter,
+ std::ranges::subrange_kind::sized>;
+using ConvertibleSizedSentinelForwardIter = SizedSentinelForwardIterBase<true>;
+using ConvertibleSizedSentinelForwardSubrange = ranges::subrange<ConvertibleSizedSentinelForwardIter, int*,
+ std::ranges::subrange_kind::sized>;
+
+using SizedIntPtrSubrange = ranges::subrange<int*, int*, std::ranges::subrange_kind::sized>;
+
+// !StoreSize ctor.
+static_assert( std::is_constructible_v<FowardSubrange, ForwardIter, ForwardIter>); // Default case.
+static_assert(!std::is_constructible_v<FowardSubrange, Empty, ForwardIter>); // 1.
+static_assert( std::is_constructible_v<ConvertibleFowardSubrange, ConvertibleForwardIter, int*>); // 2.
+static_assert( std::is_constructible_v<FowardSubrange, ForwardIter, ForwardIter>); // 3. (Same as default case.)
+// 4. and 5. must be sized.
+
+// Sized ctor.
+static_assert( std::is_constructible_v<SizedSentinelFowardSubrange, SizedSentinelForwardIter, SizedSentinelForwardIter, SizedSentinelForwardIter::udifference_type>); // Default case.
+static_assert(!std::is_constructible_v<SizedSentinelFowardSubrange, Empty, SizedSentinelForwardIter, SizedSentinelForwardIter::udifference_type>); // 1.
+static_assert( std::is_constructible_v<ConvertibleSizedSentinelForwardSubrange, ConvertibleSizedSentinelForwardIter, int*, ConvertibleSizedSentinelForwardIter::udifference_type>); // 2.
+static_assert( std::is_constructible_v<SizedSentinelFowardSubrange, SizedSentinelForwardIter, SizedSentinelForwardIter, SizedSentinelForwardIter::udifference_type>); // 3. (Same as default case.)
+static_assert(!std::is_constructible_v<SizedIntPtrSubrange, long*, int*, size_t>); // 4.
+static_assert( std::is_constructible_v<SizedIntPtrSubrange, int*, int*, size_t>); // 5.
+// TODO: is there any integral type that is not convertible to an unsized type?
+// static_assert(!std::is_constructible_v<SizedSentinelFowardSubrange, SizedSentinelForwardIter, SizedSentinelForwardIter, SizedSentinelForwardIter::difference_type>); // Not unsigned.
+
+struct ForwardBorrowedRange {
+ constexpr ForwardIter begin() const { return ForwardIter(globalBuff); }
+ constexpr ForwardIter end() const { return ForwardIter(globalBuff + 8); }
+};
+
+template<>
+inline constexpr bool ranges::enable_borrowed_range<ForwardBorrowedRange> = true;
+
+struct ForwardRange {
+ ForwardIter begin() const;
+ ForwardIter end() const;
+};
+
+struct ConvertibleForwardBorrowedRange {
+ constexpr ConvertibleForwardIter begin() const { return ConvertibleForwardIter(globalBuff); }
+ constexpr int *end() const { return globalBuff + 8; }
+};
+
+template<>
+inline constexpr bool ranges::enable_borrowed_range<ConvertibleForwardBorrowedRange> = true;
+
+struct ForwardBorrowedRangeDifferentSentienl {
+ struct sentinel {
+ int *value;
+ friend bool operator==(sentinel s, ForwardIter i) { return s.value == i.base(); }
+ };
+
+ constexpr ForwardIter begin() const { return ForwardIter(globalBuff); }
+ constexpr sentinel end() const { return sentinel{globalBuff + 8}; }
+};
+
+template<>
+inline constexpr bool ranges::enable_borrowed_range<ForwardBorrowedRangeDifferentSentienl> = true;
+
+using DifferentSentienlSubrange = ranges::subrange<ForwardIter,
+ ForwardBorrowedRangeDifferentSentienl::sentinel,
+ std::ranges::subrange_kind::unsized>;
+
+// Range ctor.
+static_assert( std::is_constructible_v<FowardSubrange, ForwardBorrowedRange>); // Default case.
+static_assert(!std::is_constructible_v<FowardSubrange, ForwardRange>); // Not borrowed.
+// Iter convertible to sentinel (pointer) type.
+static_assert( std::is_constructible_v<ConvertibleFowardSubrange, ConvertibleForwardBorrowedRange>);
+// Where neither iter or sentinel are pointers, but they are different.
+static_assert( std::is_constructible_v<DifferentSentienlSubrange, ForwardBorrowedRangeDifferentSentienl>);
+
+// Pair like conversion.
+static_assert( std::is_convertible_v<FowardSubrange, std::pair<ForwardIter, ForwardIter>>);
+static_assert( std::is_convertible_v<FowardSubrange, std::tuple<ForwardIter, ForwardIter>>);
+static_assert(!std::is_convertible_v<FowardSubrange, std::tuple<ForwardIter, ForwardIter>&>);
+static_assert(!std::is_convertible_v<FowardSubrange, std::tuple<ForwardIter, ForwardIter, ForwardIter>>);
+static_assert( std::is_convertible_v<ConvertibleFowardSubrange, std::tuple<ConvertibleForwardIter, int*>>);
+static_assert(!std::is_convertible_v<SizedIntPtrSubrange, std::tuple<long*, int*>>);
+static_assert( std::is_convertible_v<SizedIntPtrSubrange, std::tuple<int*, int*>>);
+
+constexpr bool test() {
+ FowardSubrange a(ForwardIter(globalBuff), ForwardIter(globalBuff + 8));
+ assert(a.begin().base() == globalBuff);
+ assert(a.end().base() == globalBuff + 8);
+
+ ConvertibleFowardSubrange b(ConvertibleForwardIter(globalBuff), globalBuff + 8);
+ assert(b.begin() == globalBuff);
+ assert(b.end() == globalBuff + 8);
+
+ SizedSentinelFowardSubrange d(SizedSentinelForwardIter(globalBuff), SizedSentinelForwardIter(globalBuff + 8), 8);
+ assert(d.begin().base() == globalBuff);
+ assert(d.end().base() == globalBuff + 8);
+ assert(d.size() == 8);
+
+ ConvertibleSizedSentinelForwardSubrange e(ConvertibleSizedSentinelForwardIter(globalBuff), ConvertibleSizedSentinelForwardIter(globalBuff + 8), 8);
+ assert(e.begin() == globalBuff);
+ assert(e.end() == globalBuff + 8);
+ assert(e.size() == 8);
+
+ SizedIntPtrSubrange f(globalBuff, globalBuff + 8, 8);
+ assert(f.begin() == globalBuff);
+ assert(f.end() == globalBuff + 8);
+ assert(f.size() == 8);
+
+ FowardSubrange g{ForwardBorrowedRange()};
+ assert(g.begin().base() == globalBuff);
+ assert(g.end().base() == globalBuff + 8);
+
+ ConvertibleFowardSubrange h{ConvertibleForwardBorrowedRange()};
+ assert(h.begin() == globalBuff);
+ assert(h.end() == globalBuff + 8);
+
+ DifferentSentienlSubrange i{ForwardBorrowedRangeDifferentSentienl()};
+ assert(i.begin().base() == globalBuff);
+ assert(i.end().value == globalBuff + 8);
+
+ FowardSubrange j(ForwardIter(globalBuff), ForwardIter(globalBuff + 8));
+ std::pair<ForwardIter, ForwardIter> jPair = j;
+ assert(jPair.first.base() == globalBuff);
+ assert(jPair.second.base() == globalBuff + 8);
+ std::tuple<ForwardIter, ForwardIter> jTuple = j;
+ assert(get<0>(jTuple).base() == globalBuff);
+ assert(get<1>(jTuple).base() == globalBuff + 8);
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.utility/range.subrange/general.compile.pass.cpp b/libcxx/test/std/ranges/range.utility/range.subrange/general.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.utility/range.subrange/general.compile.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
+// XFAIL: msvc && clang
+
+// class std::ranges::subrange;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+namespace ranges = std::ranges;
+
+template<std::ranges::subrange_kind K, class...Args>
+concept ValidSubrangeKind = requires { typename std::ranges::subrange<Args..., K>; };
+
+template<class...Args>
+concept ValidSubrange = requires { typename std::ranges::subrange<Args...>; };
+
+static_assert( ValidSubrange<forward_iterator<int*>>);
+static_assert( ValidSubrange<forward_iterator<int*>, forward_iterator<int*>>);
+static_assert( ValidSubrangeKind<std::ranges::subrange_kind::unsized, forward_iterator<int*>, forward_iterator<int*>>);
+static_assert( ValidSubrangeKind<std::ranges::subrange_kind::sized, forward_iterator<int*>, forward_iterator<int*>>);
+// Wrong sentinel type.
+static_assert(!ValidSubrange<forward_iterator<int*>, int*>);
+static_assert( ValidSubrange<int*>);
+static_assert( ValidSubrange<int*, int*>);
+// Must be sized.
+static_assert(!ValidSubrangeKind<std::ranges::subrange_kind::unsized, int*, int*>);
+static_assert( ValidSubrangeKind<std::ranges::subrange_kind::sized, int*, int*>);
+// Wrong sentinel type.
+static_assert(!ValidSubrange<int*, forward_iterator<int*>>);
+// Not an iterator.
+static_assert(!ValidSubrange<int>);