[libc++] mdspan: implement layout_right

[crtrott]

Summary

This commit implements layout_right in support of C++23 mdspan (https://wg21.link/p0009).
layout_right is a layout mapping policy whose index mapping corresponds to the memory layout of multidimensional C-arrays, and is thus also referred to as the C-layout.

Co-authored-by: Damien L-G <[e-mail]>

[crtrott]

Fix AIX build which has a global map_t symbol in a system header ...

[EricWF]

Great tests.

libcxx/include/__mdspan/layouts.h

34 ↗

(On Diff #525154)

I don't like adding commented or ifdefed out code like this.

Maybe just leave a comment declaration.

[crtrott]

libcxx/include/__mdspan/layouts.h

34 ↗

(On Diff #525154)

Yeah thats fine I can do that. Just gonna wait for a bit more feedback before submitting a revision.

[ldionne]

libcxx/include/__mdspan/extents.h

459

__is_index_in_extent

480

Either rename to _impl or inline it via a lambda below.

libcxx/include/__mdspan/layout_right_mapping.h

17 ↗

(On Diff #525154)

Let's make this __mdspan/layout_right.h since we're basically implementing the whole class here even though we have a "fwd decl" somewhere else.

28 ↗

(On Diff #525154)

Not necessary anymore?

46–47 ↗

(On Diff #525154)

Do you have a .verify.cpp test for this diagnostic?

I think you want something like:

//expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}MESSAGE}}

see libcxx/test/libcxx/algorithms/bad_iterator_traits.verify.cpp for example.

50–54 ↗

(On Diff #525154)

Note to self: those are tested (thanks!).

57 ↗

(On Diff #525154)

I don't think we need to make a copy here.

63–66 ↗

(On Diff #525154)

I think we could do this instead:

index_type __prod              = __ext.extent(0);
for (rank_type __r = 1; __r < extents_type::rank(); __r++) {
    bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), &__prod);
    if (__overflowed)
        return false;
}

This would avoid the division.

78 ↗

(On Diff #525154)

Do you have a test for the noexcept-ness? Edit: Yes.

84 ↗

(On Diff #525154)

Do you have a test that checks that mapping is not constructible (using a type trait) if the extents are not constructible? This is important to make sure that you implemented this using requires (or enable_if) as opposed to it just being a hard error.

116 ↗

(On Diff #525154)

Can we move this private block to the end of the class? I usually don't mind implementation details in the middle of the class, but this one is quite large so it obscures the public API a bit too much.

150 ↗

(On Diff #525154)

Please make sure you have SFINAE (or better, concepts) tests for those requirements.

155 ↗

(On Diff #525154)

return [&]<size_t ..._Pos>(index_sequence<_Pos...>) {
  index_type __result = 0;
  ((result = __idx + __extents_.extent(_Pos) * __result))...; // exercise for the reader :-)
  return __result;
}(index_sequence_for<_Indices...>{});

170 ↗

(On Diff #525154)

This is always true, so can be removed.

176 ↗

(On Diff #525154)

And this isn't necessary anymore either.

180 ↗

(On Diff #525154)

Can you make sure you have a test that we SFINAE away when the ranks are different?

libcxx/include/__mdspan/layouts.h

17 ↗

(On Diff #525154)

Let's move this to libcxx/include/__fwd/mdspan_layouts.h. While those are technically not forward declarations, they're close enough.

48–55 ↗

(On Diff #525154)

+1 let's remove those until they are implemented, or make them a comment.

libcxx/test/std/containers/views/mdspan/layout_right/conversion.pass.cpp

1 ↗

(On Diff #525154)

Let's name this ctor.mapping.pass.cpp

libcxx/test/std/containers/views/mdspan/layout_right/ctor_default.pass.cpp

1 ↗

(On Diff #525154)

Let's use ctor.default.pass.cpp, it's more consistent with what we're doing recently.

libcxx/test/std/containers/views/mdspan/layout_right/ctor_extents.pass.cpp

1 ↗

(On Diff #525154)

ctor.extents.pass.cpp

libcxx/test/std/containers/views/mdspan/layout_right/properties.pass.cpp

37

Please use a classic constexpr test here -- I'd like to make sure that these can also be called at runtime.

For example, your test (as currently written) would pass if we did something like:

static constexpr bool is_always_unique() noexcept {
  if (!std::is_constant_evaluated())
    throw "ahah";
  return true;
}

[crtrott]

libcxx/include/__mdspan/layout_right_mapping.h

155 ↗

(On Diff #525154)

template<class ... _Indices>
constexpr index_type  operator() (_Indices ... __idx) const {
   return [&]<size_t ... _Pos>(index_sequence<_Pos...>) {
     index_type __res = 0;
     ((__res = static_cast<index_type>(__idx) + __extents_.extent(_Pos) * __res),...);
     return __res;
   }(make_index_sequence<sizeof...(_Indices)>());
 }

[Mordante]

Thanks for working on this! I didn't compare the code with the Standard. A few minor nits.

libcxx/docs/Status/Cxx23.rst

43

libcxx/include/__mdspan/extents.h

458

I prefer to use concepts where possible, in requires and if constexpr. But I really would like them in requires. I still have hopes compilers can create better diagnostics for concepts than type traits. Please look at other places too.

libcxx/include/__mdspan/layout_right_mapping.h

71 ↗

(On Diff #525154)

Can this be moved to the other static_assert in this class?

libcxx/include/__mdspan/layouts.h

17 ↗

(On Diff #525154)

I would strongly suggest to use the name libcxx/include/__fwd/mdspan.h instead. The reason is the module logic of D144994 would need a special case for mdspan_layouts.h but works out of the box with mdspan.h

[crtrott]

Addressing the comments on the first round of reviews.

[crtrott]

Fix screw up in diff

[Mordante]

I didn't look closely at the patch, but I noticed an omission.

libcxx/include/__fwd/mdspan.h

44

FYI I expect the CI to fail in C++ Module std. This should be fixed by uncommenting using std::layout_right in libcxx/modules/std/mdspan.cppm. Module support has been added recently.

[crtrott]

Fixing formatting.

[crtrott]

Still problems with generated output, I can't reproduce locally yet.

[ldionne]

LGTM with a few comments! Thanks!

libcxx/include/__mdspan/layout_right.h

108

This doesn't seem to be tested directly.

libcxx/test/std/containers/views/mdspan/layout_right/ctor.default.pass.cpp

34–35

You should either address this or remove the comment.

39

This would belong to the direct test for required_span_size() instead, for example.

libcxx/test/std/containers/views/mdspan/layout_right/ctor.mapping.pass.cpp

80

(maybe elsewhere if you copy-pasted, just grep)

libcxx/test/std/containers/views/mdspan/layout_right/index_operator.pass.cpp

32

Let's use libcxx/test/std/containers/views/mdspan/extents/ConvertibleToIntegral.h (which you can move to libcxx/test/std/containers/views/mdspan/ instead).

87–91

Let's test with a few 1-sized dimensions.

[ldionne]

libcxx/test/std/containers/views/mdspan/layout_right/ctor.mapping.pass.cpp

23

I don't think you're using anything from that header.

[crtrott]

Address last comments

[crtrott]

libcxx/include/__mdspan/layout_right_mapping.h

71 ↗

(On Diff #525154)

I think it would make it less readable. We need to test the first static_assert before we use the template parameter for dependent types, and the second static_assert impl requires those dependent types.

[ldionne]

LGTM with passing CI.

[crtrott]

With assertion enabled one of the tests we expanded in the last commit hit the default maximum step limit in consteval. I split the test now and run the large iteration case only in runtime mode, not in consteval.

[ldionne]

LGTM with nits.

libcxx/test/std/containers/views/mdspan/layout_right/required_span_size.pass.cpp

13–18

This is wrong.

26–34

[crtrott]

Fix wrong comment and test name for required_span_size

[ldionne]

libcxx/test/std/containers/views/mdspan/layout_right/required_span_size.pass.cpp

29

I think this comment can be removed.

[ldionne]

libcxx/test/std/containers/views/mdspan/layout_right/assert.stride.pass.cpp

2

This is a nitipck, but I noticed this upon applying the patch. You're missing the first line of the license comment.

Don't change anything, I'm editing upon committing. Just FYI.

libcxx/docs/Status/Cxx23.rst

 
 .. csv-table::
    :file: Cxx23Papers.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
+   .. [#note-P0009R18] P0009R18: ``extents``, ``dextents``, and ``layout_right`` are implemented.
    .. [#note-P0533R9] P0533R9: ``isfinite``, ``isinf``, ``isnan`` and ``isnormal`` are implemented.
    .. [#note-P1413R3] P1413R3: ``std::aligned_storage_t`` and ``std::aligned_union_t`` are marked deprecated, but
       clang doesn't issue a diagnostic for deprecated using template declarations.
    .. [#note-P2520R0] P2520R0: Libc++ implemented this paper as a DR in C++20 as well.
    .. [#note-P2711R1] P2711R1: ``join_with_view`` hasn't been done yet since this type isn't implemented yet.
    .. [#note-P2693R1] P1413R3: The formatter for ``std::thread::id`` is implemented.
       The formatter for ``stacktrace`` is not implemented, since ``stacktrace`` is
       not implemented yet.

libcxx/docs/Status/Cxx23Papers.csv

 "`P2255R2 <https://wg21.link/P2255R2>`__","LWG","A type trait to detect reference binding to temporary","February 2022","",""
 "`P2273R3 <https://wg21.link/P2273R3>`__","LWG","Making ``std::unique_ptr`` constexpr","February 2022","|Complete|","16.0"
 "`P2387R3 <https://wg21.link/P2387R3>`__","LWG","Pipe support for user-defined range adaptors","February 2022","","","|ranges|"
 "`P2440R1 <https://wg21.link/P2440R1>`__","LWG","``ranges::iota``, ``ranges::shift_left`` and ``ranges::shift_right``","February 2022","","","|ranges|"
 "`P2441R2 <https://wg21.link/P2441R2>`__","LWG","``views::join_with``","February 2022","","","|ranges|"
 "`P2442R1 <https://wg21.link/P2442R1>`__","LWG","Windowing range adaptors: ``views::chunk`` and ``views::slide``","February 2022","","","|ranges|"
 "`P2443R1 <https://wg21.link/P2443R1>`__","LWG","``views::chunk_by``","February 2022","","","|ranges|"
 "","","","","","",""
-"`P0009R18 <https://wg21.link/P0009R18>`__","LWG","mdspan: A Non-Owning Multidimensional Array Reference","July 2022","|In progress|",""
+"`P0009R18 <https://wg21.link/P0009R18>`__","LWG","mdspan: A Non-Owning Multidimensional Array Reference","July 2022","|In progress| [#note-P0009R18]_|",""
 "`P0429R9 <https://wg21.link/P0429R9>`__","LWG","A Standard ``flat_map``","July 2022","",""
 "`P1169R4 <https://wg21.link/P1169R4>`__","LWG","``static operator()``","July 2022","|Complete|","16.0"
 "`P1222R4 <https://wg21.link/P1222R4>`__","LWG","A Standard ``flat_set``","July 2022","",""
 "`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","","","|ranges|"
 "`P1467R9 <https://wg21.link/P1467R9>`__","LWG","Extended ``floating-point`` types and standard names","July 2022","",""
 "`P1642R11 <https://wg21.link/P1642R11>`__","LWG","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","July 2022","",""
 "`P1899R3 <https://wg21.link/P1899R3>`__","LWG","``stride_view``","July 2022","","","|ranges|"
 "`P2093R14 <https://wg21.link/P2093R14>`__","LWG","Formatted output","July 2022","",""

libcxx/include/CMakeLists.txt

set(files
   __functional/unary_negate.h
   __functional/weak_result_type.h
   __fwd/array.h
   __fwd/fstream.h
   __fwd/get.h
   __fwd/hash.h
   __fwd/ios.h
   __fwd/istream.h
+  __fwd/mdspan.h
   __fwd/memory_resource.h
   __fwd/ostream.h
   __fwd/pair.h
   __fwd/span.h
   __fwd/sstream.h
   __fwd/streambuf.h
   __fwd/string.h
   __fwd/string_view.h
set(files
   __iterator/unreachable_sentinel.h
   __iterator/wrap_iter.h
   __locale
   __locale_dir/locale_base_api/bsd_locale_defaults.h
   __locale_dir/locale_base_api/bsd_locale_fallbacks.h
   __locale_dir/locale_base_api/locale_guard.h
   __mbstate_t.h
   __mdspan/extents.h
+  __mdspan/layout_right.h
   __memory/addressof.h
   __memory/align.h
   __memory/aligned_alloc.h
   __memory/allocate_at_least.h
   __memory/allocation_guard.h
   __memory/allocator.h
   __memory/allocator_arg_t.h
   __memory/allocator_destructor.h

libcxx/include/__fwd/mdspan.h

+// -*- 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
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MDSPAN_LAYOUTS_H
+#define _LIBCPP___MDSPAN_LAYOUTS_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+/*
+// Will be implemented with follow on revision
+// Layout policy with a mapping which corresponds to FORTRAN-style array layouts
+struct layout_left {
+  template<class Extents>
+    class mapping;
+};
+*/
+
+// Layout policy with a mapping which corresponds to C-style array layouts
+struct layout_right {
+  template <class Extents>
+  class mapping;
+};
+
+/*
+// Will be implemented with follow on revision
+// Layout policy with a unique mapping where strides are arbitrary
+struct layout_stride {
+  template<class Extents>
+    class mapping;
+};
+*/
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MDSPAN_LAYOUTS_H

libcxx/include/__mdspan/extents.h

public:
   _LIBCPP_HIDE_FROM_ABI static constexpr size_t __size() { return __size_; }
   _LIBCPP_HIDE_FROM_ABI static constexpr size_t __size_dynamic() { return __size_dynamic_; }
 };
 
 // Function to check whether a value is representable as another type
 // value must be a positive integer otherwise returns false
 // if _From is not an integral, we just check positivity
 template <integral _To, class _From>
-  requires(is_integral_v<_From>)
+  requires(integral<_From>)
 _LIBCPP_HIDE_FROM_ABI constexpr bool __is_representable_as(_From __value) {
   using _To_u   = make_unsigned_t<_To>;
   using _From_u = make_unsigned_t<_From>;
   if constexpr (is_signed_v<_From>) {
     if (__value < 0)
       return false;
   }
   if constexpr (static_cast<_To_u>(numeric_limits<_To>::max()) >= static_cast<_From_u>(numeric_limits<_From>::max())) {
     return true;
   } else {
     return static_cast<_To_u>(numeric_limits<_To>::max()) >= static_cast<_From_u>(__value);
   }
 }
 
 template <integral _To, class _From>
-  requires(!is_integral_v<_From>)
+  requires(!integral<_From>)
 _LIBCPP_HIDE_FROM_ABI constexpr bool __is_representable_as(_From __value) {
   if constexpr (is_signed_v<_To>) {
     if (static_cast<_To>(__value) < 0)
       return false;
   }
   return true;
 }
 

 // [mdspan.extents.dextents], alias template
 template <class _IndexType, size_t _Rank>
 using dextents = typename __mdspan_detail::__make_dextents<_IndexType, _Rank>::type;
 
 // Deduction guide for extents
 template <class... _IndexTypes>
 extents(_IndexTypes...) -> extents<size_t, size_t((_IndexTypes(), dynamic_extent))...>;
 
-// Helper type traits for identifying a class as extents.
 namespace __mdspan_detail {
 
+// Helper type traits for identifying a class as extents.
 template <class _Tp>
 struct __is_extents : false_type {};
 
 template <class _IndexType, size_t... _ExtentsPack>
 struct __is_extents<extents<_IndexType, _ExtentsPack...>> : true_type {};
 
 template <class _Tp>
 inline constexpr bool __is_extents_v = __is_extents<_Tp>::value;
 
+// Function to check whether a set of indices are a multidimensional
+// index into extents. This is a word of power in the C++ standard
+// requiring that the indices are larger than 0 and smaller than
+// the respective extents.
+
+template <integral _IndexType, class _From>
+  requires(integral<_From>)
+_LIBCPP_HIDE_FROM_ABI constexpr bool __is_index_in_extent(_IndexType __extent, _From __value) {
+  if constexpr (is_signed_v<_From>) {
+    if (__value < 0)
+      return false;
+  }
+  using _Tp = common_type_t<_IndexType, _From>;
+  return static_cast<_Tp>(__value) < static_cast<_Tp>(__extent);
+}
+
+template <integral _IndexType, class _From>
+  requires(!integral<_From>)
+_LIBCPP_HIDE_FROM_ABI constexpr bool __is_index_in_extent(_IndexType __extent, _From __value) {
+  if constexpr (is_signed_v<_IndexType>) {
+    if (static_cast<_IndexType>(__value) < 0)
+      return false;
+  }
+  return static_cast<_IndexType>(__value) < __extent;
+}
+
+template <size_t... _Idxs, class _Extents, class... _From>
+_LIBCPP_HIDE_FROM_ABI constexpr bool
+__is_multidimensional_index_in_impl(index_sequence<_Idxs...>, const _Extents& __ext, _From... __values) {
+  return (__mdspan_detail::__is_index_in_extent(__ext.extent(_Idxs), __values) && ...);
+}
+
+template <class _Extents, class... _From>
+_LIBCPP_HIDE_FROM_ABI constexpr bool __is_multidimensional_index_in(const _Extents& __ext, _From... __values) {
+  return __mdspan_detail::__is_multidimensional_index_in_impl(
+      make_index_sequence<_Extents::rank()>(), __ext, __values...);
+}
+
 } // namespace __mdspan_detail
 
 #endif // _LIBCPP_STD_VER >= 23
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___MDSPAN_EXTENTS_H

libcxx/include/__mdspan/layout_right.h

+// -*- 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
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MDSPAN_LAYOUT_RIGHT_H
+#define _LIBCPP___MDSPAN_LAYOUT_RIGHT_H
+
+#include <__assert>
+#include <__config>
+#include <__fwd/mdspan.h>
+#include <__mdspan/extents.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/integer_sequence.h>
+#include <cinttypes>
+#include <cstddef>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Extents>
+class layout_right::mapping {
+public:
+  static_assert(__mdspan_detail::__is_extents<_Extents>::value,
+                "layout_right::mapping template argument must be a specialization of extents.");
+
+  using extents_type = _Extents;
+  using index_type   = typename extents_type::index_type;
+  using size_type    = typename extents_type::size_type;
+  using rank_type    = typename extents_type::rank_type;
+  using layout_type  = layout_right;
+
+private:
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __required_span_size_is_representable(const extents_type& __ext) {
+    if constexpr (extents_type::rank() == 0)
+      return true;
+
+    index_type __prod = __ext.extent(0);
+    for (rank_type __r = 1; __r < extents_type::rank(); __r++) {
+      bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), &__prod);
+      if (__overflowed)
+        return false;
+    }
+    return true;
+  }
+
+  static_assert((extents_type::rank_dynamic() > 0) || __required_span_size_is_representable(extents_type()),
+                "layout_right::mapping product of static extents must be representable as index_type.");
+
+public:
+  // [mdspan.layout.right.cons], constructors
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping() noexcept               = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const mapping&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext) noexcept : __extents_(__ext) {
+    _LIBCPP_ASSERT(__required_span_size_is_representable(__ext),
+                   "layout_right::mapping extents ctor: product of extents must be representable as index_type.");
+  }
+
+  template <class _OtherExtents>
+    requires(is_constructible_v<extents_type, _OtherExtents>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+      mapping(const mapping<_OtherExtents>& __other) noexcept
+      : __extents_(__other.extents()) {
+    _LIBCPP_ASSERT(
+        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
+        "layout_right::mapping converting ctor: other.required_span_size() must be representable as index_type.");
+  }
+
+// FIXME: add when we add other layouts
+#  if 0
+    template<class _OtherExtents>
+      constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+        mapping(const layout_left::mapping<_OtherExtents>&) noexcept {}
+
+    template<class _OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping_<OtherExtents>&) noexcept;
+#  endif
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping& operator=(const mapping&) noexcept = default;
+
+  // [mdspan.layout.right.obs], observers
+  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __extents_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type required_span_size() const noexcept {
+    index_type __size = 1;
+    for (size_t __r = 0; __r < extents_type::rank(); __r++)
+      __size *= __extents_.extent(__r);
+    return __size;
+  }
+
+  template <class... _Indices>
+    requires((sizeof...(_Indices) == extents_type::rank()) && (is_convertible_v<_Indices, index_type> && ...) &&
+             (is_nothrow_constructible_v<index_type, _Indices> && ...))
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type operator()(_Indices... __idx) const noexcept {
+    _LIBCPP_ASSERT(__mdspan_detail::__is_multidimensional_index_in(__extents_, __idx...),
+                   "layout_right::mapping: out of bounds indexing");
+    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+      index_type __res = 0;
+      ((__res = static_cast<index_type>(__idx) + __extents_.extent(_Pos) * __res), ...);
+      return __res;
+    }(make_index_sequence<sizeof...(_Indices)>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept { return true; }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_unique() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_exhaustive() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_strided() noexcept { return true; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const noexcept
+    requires(extents_type::rank() > 0)
+  {
+    _LIBCPP_ASSERT(__r < extents_type::rank(), "layout_right::mapping::stride(): invalid rank index");
+    index_type __s = 1;
+    for (rank_type __i = extents_type::rank() - 1; __i > __r; __i--)
+      __s *= __extents_.extent(__i);
+    return __s;
+  }
+
+  template <class _OtherExtents>
+    requires(_OtherExtents::rank() == extents_type::rank())
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept {
+    return __lhs.extents() == __rhs.extents();
+  }
+
+private:
+  extents_type __extents_{}; // exposition only
+};
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MDSPAN_LAYOUT_RIGHT_H

libcxx/include/mdspan

 // -*-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
 //
 //===---------------------------------------------------------------------===//
 
 /*
-    extents synopsis
+
+// Overall mdspan synopsis
+
+namespace std {
+  // [mdspan.extents], class template extents
+  template<class IndexType, size_t... Extents>
+    class extents;
+
+  // [mdspan.extents.dextents], alias template dextents
+  template<class IndexType, size_t Rank>
+    using dextents = see below;
+
+  // [mdspan.layout], layout mapping
+  struct layout_left; // not implemented yet
+  struct layout_right;
+  struct layout_stride; // not implemented yet
+
+  // [mdspan.accessor.default], class template default_accessor
+  template<class ElementType>
+    class default_accessor; // not implemented yet
+
+  // [mdspan.mdspan], class template mdspan
+  template<class ElementType, class Extents, class LayoutPolicy = layout_right,
+           class AccessorPolicy = default_accessor<ElementType>>
+    class mdspan; // not implemented yet
+}
+
+// extents synopsis
 
 namespace std {
   template<class _IndexType, size_t... _Extents>
   class extents {
   public:
     using index_type = _IndexType;
     using size_type = make_unsigned_t<index_type>;
     using rank_type = size_t;
private:
     // for example the default constructor must zero initialize dynamic extents
     array<index_type, rank_dynamic()> dynamic-extents{};                // exposition only
   };
 
   template<class... Integrals>
     explicit extents(Integrals...)
       -> see below;
 }
+
+// layout_right synopsis
+
+namespace std {
+  template<class Extents>
+  class layout_right::mapping {
+  public:
+    using extents_type = Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_right;
+
+    // [mdspan.layout.right.cons], constructors
+    constexpr mapping() noexcept = default;
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_left::mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&) noexcept;
+
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+
+    // [mdspan.layout.right.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+
+    constexpr index_type required_span_size() const noexcept;
+
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return true; }
+    static constexpr bool is_always_strided() noexcept { return true; }
+
+    static constexpr bool is_unique() noexcept { return true; }
+    static constexpr bool is_exhaustive() noexcept { return true; }
+    static constexpr bool is_strided() noexcept { return true; }
+
+    constexpr index_type stride(rank_type) const noexcept;
+
+    template<class OtherExtents>
+      friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
+
+  private:
+    extents_type extents_{};    // exposition only
+  };
+}
+
 */
 
 #ifndef _LIBCPP_MDSPAN
 #define _LIBCPP_MDSPAN
 
 #include <__config>
+#include <__fwd/mdspan.h>
 #include <__mdspan/extents.h>
+#include <__mdspan/layout_right.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_MDSPAN

libcxx/include/module.modulemap.in

   module mdspan {
     header "mdspan"
     export array
     export span
     export *
 
     module __mdspan {
       module extents                         { private header "__mdspan/extents.h" }
+      module layout_right                    { private header "__mdspan/layout_right.h" }
+      module mdspan_fwd                      { private header "__fwd/mdspan.h" }
     }
   }
   module memory {
     header "memory"
     export *
 
     module __memory {
       module addressof                       { private header "__memory/addressof.h" }

libcxx/modules/std/mdspan.cppm

 export module std:mdspan;
 export namespace std {
   // [mdspan.extents], class template extents
   using std::extents;
 
   // [mdspan.extents.dextents], alias template dextents
   using std::dextents;
 
-#if 0
   // [mdspan.layout], layout mapping
-  using std::layout_left;
+  // using std::layout_left;
   using std::layout_right;
-  using std::layout_stride;
+  // using std::layout_stride;
 
+#if 0
   // [mdspan.accessor.default], class template default_­accessor
   using std::default_accessor;
 
   // [mdspan.mdspan], class template mdspan
   using std::mdspan;
 #endif
 } // namespace std

libcxx/test/std/containers/views/mdspan/ConvertibleToIntegral.h

 //===----------------------------------------------------------------------===//
 //
 // 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 TEST_STD_CONTAINERS_CONVERTIBLE_TO_INTEGRAL_H
-#define TEST_STD_CONTAINERS_CONVERTIBLE_TO_INTEGRAL_H
+#ifndef TEST_STD_CONTAINERS_VIEWS_MDSPAN_LAYOUT_RIGHT_CONVERTIBLE_TO_INTEGRAL_H
+#define TEST_STD_CONTAINERS_VIEWS_MDSPAN_LAYOUT_RIGHT_CONVERTIBLE_TO_INTEGRAL_H
 
 struct IntType {
   int val;
   constexpr IntType() = default;
   constexpr IntType(int v) noexcept : val(v){};
 
   constexpr bool operator==(const IntType& rhs) const { return val == rhs.val; }
   constexpr operator int() const noexcept { return val; }
-  constexpr operator unsigned char() const noexcept { return val; }
+  constexpr operator unsigned char() const { return val; }
+  constexpr operator char() const noexcept { return val; }
 };
 
-#endif // TEST_STD_CONTAINERS_CONVERTIBLE_TO_INTEGRAL_H
+#endif // TEST_STD_CONTAINERS_VIEWS_MDSPAN_LAYOUT_RIGHT_CONVERTIBLE_TO_INTEGRAL_H

libcxx/test/std/containers/views/mdspan/extents/CtorTestCombinations.h

 //===----------------------------------------------------------------------===//
 //
 // 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, c++20
 
 // <mdspan>
 
 #include <mdspan>
 #include <cassert>
 #include <array>
 #include <span>
 
-#include "ConvertibleToIntegral.h"
+#include "../ConvertibleToIntegral.h"
 #include "test_macros.h"
 
 // Helper file to implement combinatorical testing of extents constructor
 //
 // std::extents can be constructed from just indices, a std::array, or a std::span
 // In each of those cases one can either provide all extents, or just the dynamic ones
 // If constructed from std::span, the span needs to have a static extent
 // Furthermore, the indices/array/span can have integer types other than index_type
constexpr bool test_index_type_combo() {
   test<int, int, Test>();
   test<int, size_t, Test>();
   test<unsigned, int, Test>();
   test<char, size_t, Test>();
   test<long long, unsigned, Test>();
   test<size_t, int, Test>();
   test<size_t, size_t, Test>();
   test<int, IntType, Test>();
-  test<unsigned char, IntType, Test>();
+  test<char, IntType, Test>();
   return true;
 }

libcxx/test/std/containers/views/mdspan/extents/ctad.pass.cpp

 // explicit extents(Integrals...) -> see below;
 //   Constraints: (is_convertible_v<Integrals, size_t> && ...) is true.
 //
 // Remarks: The deduced type is dextents<size_t, sizeof...(Integrals)>.
 
 #include <mdspan>
 #include <cassert>
 
-#include "ConvertibleToIntegral.h"
+#include "../ConvertibleToIntegral.h"
 #include "test_macros.h"
 
 template <class E, class Expected>
 constexpr void test(E e, Expected expected) {
   ASSERT_SAME_TYPE(E, Expected);
   assert(e == expected);
 }
 

libcxx/test/std/containers/views/mdspan/extents/ctor_default.pass.cpp

 //
 // Remarks: since the standard uses an exposition only array member, dynamic extents
 // need to be zero intialized!
 
 #include <mdspan>
 #include <cassert>
 #include <array>
 
-#include "ConvertibleToIntegral.h"
+#include "../ConvertibleToIntegral.h"
 #include "CtorTestCombinations.h"
 #include "test_macros.h"
 
 struct DefaultCtorTest {
   template <class E, class AllExtents, class Extents, size_t... Indices>
   static constexpr void test_construction(AllExtents all_ext, Extents, std::index_sequence<Indices...>) {
     // This function gets called twice: once with Extents being just the dynamic ones, and once with all the extents specified.
     // We only test during the all extent case, since then Indices is the correct number. This allows us to reuse the same

libcxx/test/std/containers/views/mdspan/extents/ctor_from_array.pass.cpp

 //       for every rank index r.
 //
 
 #include <mdspan>
 #include <cassert>
 #include <array>
 #include <type_traits>
 
-#include "ConvertibleToIntegral.h"
+#include "../ConvertibleToIntegral.h"
 #include "CtorTestCombinations.h"
 #include "test_macros.h"
 
 struct ArrayCtorTest {
   template <class E, class T, size_t N, class Extents, size_t... Indices>
   static constexpr void test_construction(std::array<T, N> all_ext, Extents ext, std::index_sequence<Indices...>) {
     ASSERT_NOEXCEPT(E(ext));
     if constexpr (N == E::rank_dynamic()) {

libcxx/test/std/containers/views/mdspan/extents/ctor_from_integral.pass.cpp

 //     - sizeof...(exts) == 0 is true, or
 //     - each element of exts is nonnegative and is representable as a value of type index_type.
 //
 
 #include <mdspan>
 #include <cassert>
 #include <type_traits>
 
-#include "ConvertibleToIntegral.h"
+#include "../ConvertibleToIntegral.h"
 #include "CtorTestCombinations.h"
 #include "test_macros.h"
 
 struct IntegralCtorTest {
   template <class E, class AllExtents, class Extents, size_t... Indices>
   static constexpr void test_construction(AllExtents all_ext, Extents ext, std::index_sequence<Indices...>) {
     // construction from indices
     ASSERT_NOEXCEPT(E(ext[Indices]...));

libcxx/test/std/containers/views/mdspan/extents/ctor_from_span.pass.cpp

 //
 
 #include <mdspan>
 #include <cassert>
 #include <array>
 #include <span>
 #include <type_traits>
 
-#include "ConvertibleToIntegral.h"
+#include "../ConvertibleToIntegral.h"
 #include "CtorTestCombinations.h"
 #include "test_macros.h"
 
 struct SpanCtorTest {
   template <class E, class T, size_t N, class Extents, size_t... Indices>
   static constexpr void test_construction(std::array<T, N> all_ext, Extents ext, std::index_sequence<Indices...>) {
     ASSERT_NOEXCEPT(E(ext));
     if constexpr (N == E::rank_dynamic()) {

libcxx/test/std/containers/views/mdspan/layout_right/assert.conversion.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: availability-verbose_abort-missing
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// <mdspan>
+
+// template<class OtherExtents>
+//   constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+//     mapping(const mapping<OtherExtents>&) noexcept;
+
+// Constraints: is_constructible_v<extents_type, OtherExtents> is true.
+//
+// Preconditions: other.required_span_size() is representable as a value of type index_type.
+
+#include <mdspan>
+#include <cassert>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  constexpr size_t D = std::dynamic_extent;
+  std::extents<int, D, D> arg_exts{100, 5};
+  std::layout_right::mapping<std::extents<int, D, D>> arg(arg_exts);
+
+  // working case
+  {
+    [[maybe_unused]] std::layout_right::mapping<std::extents<size_t, D, 5>> m(arg); // should work
+  }
+  // mismatch of static extent
+  {
+    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_right::mapping<std::extents<int, D, 3>> m(arg); }()),
+                               "extents construction: mismatch of provided arguments with static extents.");
+  }
+  // value out of range
+  {
+    // check extents would be constructible
+    [[maybe_unused]] std::extents<char, D, 5> e(arg_exts);
+    // but the product is not, so we can't use it for layout_right
+    TEST_LIBCPP_ASSERT_FAILURE(
+        ([=] { std::layout_right::template mapping<std::extents<char, D, 5>> m(arg); }()),
+        "layout_right::mapping converting ctor: other.required_span_size() must be representable as index_type.");
+  }
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/assert.ctor.extents.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: availability-verbose_abort-missing
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// <mdspan>
+
+// constexpr mapping(const extents_type& e) noexcept;
+//
+// Preconditions: The size of the multidimensional index space e is representable as a value of type index_type ([basic.fundamental]).
+//
+// Effects: Direct-non-list-initializes extents_ with e.
+
+#include <mdspan>
+#include <cassert>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  constexpr size_t D = std::dynamic_extent;
+
+  // value out of range
+  {
+    // the extents are representable but the product is not, so we can't use it for layout_right
+    TEST_LIBCPP_ASSERT_FAILURE(
+        ([=] { std::layout_right::template mapping<std::extents<char, D, 5>> m(std::extents<char, D, 5>(100)); }()),
+        "layout_right::mapping extents ctor: product of extents must be representable as index_type.");
+  }
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/assert.index_operator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: availability-verbose_abort-missing
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// <mdspan>
+
+// template<class... Indices>
+//   constexpr index_type operator()(Indices... i) const noexcept;
+//
+// Constraints:
+//   - sizeof...(Indices) == extents_type::rank() is true,
+//   - (is_convertible_v<Indices, index_type> && ...) is true, and
+//   - (is_nothrow_constructible_v<index_type, Indices> && ...) is true.
+//
+// Preconditions: extents_type::index-cast(i) is a multidimensional index in extents_ ([mdspan.overview]).
+
+#include <mdspan>
+#include <cassert>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  // value out of range
+  {
+    std::layout_right::template mapping<std::extents<unsigned char, 5>> m;
+    TEST_LIBCPP_ASSERT_FAILURE(m(-1), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(-130), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(5), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(1000), "layout_right::mapping: out of bounds indexing");
+  }
+  {
+    std::layout_right::template mapping<std::extents<signed char, 5>> m;
+    TEST_LIBCPP_ASSERT_FAILURE(m(-1), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(-130), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(5), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(1000), "layout_right::mapping: out of bounds indexing");
+  }
+  {
+    std::layout_right::template mapping<std::dextents<unsigned char, 1>> m(std::dextents<unsigned char, 1>(5));
+    TEST_LIBCPP_ASSERT_FAILURE(m(-1), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(-130), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(5), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(1000), "layout_right::mapping: out of bounds indexing");
+  }
+  {
+    std::layout_right::template mapping<std::dextents<signed char, 1>> m(std::dextents<signed char, 1>(5));
+    TEST_LIBCPP_ASSERT_FAILURE(m(-1), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(-130), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(5), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(1000), "layout_right::mapping: out of bounds indexing");
+  }
+  {
+    std::layout_right::template mapping<std::dextents<int, 3>> m(std::dextents<int, 3>(5, 7, 9));
+    TEST_LIBCPP_ASSERT_FAILURE(m(-1, -1, -1), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(-1, 0, 0), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(0, -1, 0), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(0, 0, -1), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(5, 3, 3), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(3, 7, 3), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(3, 3, 9), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(5, 7, 9), "layout_right::mapping: out of bounds indexing");
+  }
+  {
+    std::layout_right::template mapping<std::dextents<unsigned, 3>> m(std::dextents<int, 3>(5, 7, 9));
+    TEST_LIBCPP_ASSERT_FAILURE(m(-1, -1, -1), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(-1, 0, 0), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(0, -1, 0), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(0, 0, -1), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(5, 3, 3), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(3, 7, 3), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(3, 3, 9), "layout_right::mapping: out of bounds indexing");
+    TEST_LIBCPP_ASSERT_FAILURE(m(5, 7, 9), "layout_right::mapping: out of bounds indexing");
+  }
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/assert.stride.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: availability-verbose_abort-missing
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// <mdspan>
+
+// layout_right::mapping
+//
+// constexpr index_type stride(rank_type i) const noexcept;
+//
+//   Constraints: extents_type::rank() > 0 is true.
+//
+//   Preconditions: i < extents_type::rank() is true.
+//
+//   Returns: extents().rev-prod-of-extents(i).
+//
+//
+
+#include <mdspan>
+#include <cassert>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  // value out of range
+  {
+    std::layout_right::template mapping<std::dextents<int, 3>> m{std::dextents<int, 3>{100, 100, 100}};
+
+    TEST_LIBCPP_ASSERT_FAILURE(m.stride(4), "invalid rank index");
+  }
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/comparison.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// template<class OtherExtents>
+//   friend constexpr bool operator==(const mapping& x, const mapping<OtherExtents>& y) noexcept;
+//                                      `
+// Constraints: extents_type::rank() == OtherExtents::rank() is true.
+
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class To, class From>
+constexpr void test_comparison(bool equal, To dest_exts, From src_exts) {
+  std::layout_right::mapping<To> dest(dest_exts);
+  std::layout_right::mapping<From> src(src_exts);
+  ASSERT_NOEXCEPT(dest == src);
+  assert((dest == src) == equal);
+  assert((dest != src) == !equal);
+}
+
+struct X {
+  constexpr bool does_not_match() { return true; }
+};
+
+constexpr X compare_layout_mappings(...) { return {}; }
+
+template <class E1, class E2>
+constexpr auto compare_layout_mappings(E1 e1, E2 e2)
+    -> decltype(std::layout_right::mapping<E1>(e1) == std::layout_right::mapping<E2>(e2)) {
+  return true;
+}
+
+template <class T1, class T2>
+constexpr void test_comparison_different_rank() {
+  constexpr size_t D = std::dynamic_extent;
+
+  // sanity check same rank
+  static_assert(compare_layout_mappings(std::extents<T1, D>(5), std::extents<T2, D>(5)));
+  static_assert(compare_layout_mappings(std::extents<T1, 5>(), std::extents<T2, D>(5)));
+  static_assert(compare_layout_mappings(std::extents<T1, D>(5), std::extents<T2, 5>()));
+  static_assert(compare_layout_mappings(std::extents<T1, 5>(), std::extents<T2, 5>()));
+
+  // not equality comparable when rank is not the same
+  static_assert(compare_layout_mappings(std::extents<T1>(), std::extents<T2, D>(1)).does_not_match());
+  static_assert(compare_layout_mappings(std::extents<T1>(), std::extents<T2, 1>()).does_not_match());
+
+  static_assert(compare_layout_mappings(std::extents<T1, D>(1), std::extents<T2>()).does_not_match());
+  static_assert(compare_layout_mappings(std::extents<T1, 1>(), std::extents<T2>()).does_not_match());
+
+  static_assert(compare_layout_mappings(std::extents<T1, D>(5), std::extents<T2, D, D>(5, 5)).does_not_match());
+  static_assert(compare_layout_mappings(std::extents<T1, 5>(), std::extents<T2, 5, D>(5)).does_not_match());
+  static_assert(compare_layout_mappings(std::extents<T1, 5>(), std::extents<T2, 5, 1>()).does_not_match());
+
+  static_assert(compare_layout_mappings(std::extents<T1, D, D>(5, 5), std::extents<T2, D>(5)).does_not_match());
+  static_assert(compare_layout_mappings(std::extents<T1, 5, D>(5), std::extents<T2, D>(5)).does_not_match());
+  static_assert(compare_layout_mappings(std::extents<T1, 5, 5>(), std::extents<T2, 5>()).does_not_match());
+}
+
+template <class T1, class T2>
+constexpr void test_comparison_same_rank() {
+  constexpr size_t D = std::dynamic_extent;
+
+  test_comparison(true, std::extents<T1>(), std::extents<T2>());
+
+  test_comparison(true, std::extents<T1, D>(5), std::extents<T2, D>(5));
+  test_comparison(true, std::extents<T1, 5>(), std::extents<T2, D>(5));
+  test_comparison(true, std::extents<T1, D>(5), std::extents<T2, 5>());
+  test_comparison(true, std::extents<T1, 5>(), std::extents< T2, 5>());
+  test_comparison(false, std::extents<T1, D>(5), std::extents<T2, D>(7));
+  test_comparison(false, std::extents<T1, 5>(), std::extents<T2, D>(7));
+  test_comparison(false, std::extents<T1, D>(5), std::extents<T2, 7>());
+  test_comparison(false, std::extents<T1, 5>(), std::extents<T2, 7>());
+
+  test_comparison(true, std::extents<T1, D, D, D, D, D>(5, 6, 7, 8, 9), std::extents<T2, D, D, D, D, D>(5, 6, 7, 8, 9));
+  test_comparison(true, std::extents<T1, D, 6, D, 8, D>(5, 7, 9), std::extents<T2, 5, D, D, 8, 9>(6, 7));
+  test_comparison(true, std::extents<T1, 5, 6, 7, 8, 9>(5, 6, 7, 8, 9), std::extents<T2, 5, 6, 7, 8, 9>());
+  test_comparison(
+      false, std::extents<T1, D, D, D, D, D>(5, 6, 7, 8, 9), std::extents<T2, D, D, D, D, D>(5, 6, 3, 8, 9));
+  test_comparison(false, std::extents<T1, D, 6, D, 8, D>(5, 7, 9), std::extents<T2, 5, D, D, 3, 9>(6, 7));
+  test_comparison(false, std::extents<T1, 5, 6, 7, 8, 9>(5, 6, 7, 8, 9), std::extents<T2, 5, 6, 7, 3, 9>());
+}
+
+template <class T1, class T2>
+constexpr void test_comparison() {
+  test_comparison_same_rank<T1, T2>();
+  test_comparison_different_rank<T1, T2>();
+}
+
+constexpr bool test() {
+  test_comparison<int, int>();
+  test_comparison<int, size_t>();
+  test_comparison<size_t, int>();
+  test_comparison<size_t, long>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// Test default construction:
+//
+// constexpr mapping() noexcept = default;
+
+#include <mdspan>
+#include <cassert>
+#include <cstdint>
+
+#include "test_macros.h"
+
+template <class E>
+constexpr void test_construction() {
+  using M = std::layout_right::mapping<E>;
+  ASSERT_NOEXCEPT(M{});
+  M m;
+  E e;
+
+  // check correct extents are returned
+  ASSERT_NOEXCEPT(m.extents());
+  assert(m.extents() == e);
+
+  // check required_span_size()
+  typename E::index_type expected_size = 1;
+  for (typename E::rank_type r = 0; r < E::rank(); r++)
+    expected_size *= e.extent(r);
+  assert(m.required_span_size() == expected_size);
+}
+
+constexpr bool test() {
+  constexpr size_t D = std::dynamic_extent;
+  test_construction<std::extents<int>>();
+  test_construction<std::extents<unsigned, D>>();
+  test_construction<std::extents<unsigned, 7>>();
+  test_construction<std::extents<unsigned, 7, 8>>();
+  test_construction<std::extents<int64_t, D, 8, D, D>>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/ctor.extents.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// constexpr mapping(const extents_type&) noexcept;
+//
+// Preconditions: The size of the multidimensional index space e is representable
+//                as a value of type index_type ([basic.fundamental]).
+//
+// Effects: Direct-non-list-initializes extents_ with e.
+
+#include <mdspan>
+#include <cassert>
+#include <cstdint>
+
+#include "test_macros.h"
+
+template <class E>
+constexpr void test_construction(E e) {
+  using M = std::layout_right::mapping<E>;
+  ASSERT_NOEXCEPT(M{e});
+  M m(e);
+
+  // check correct extents are returned
+  ASSERT_NOEXCEPT(m.extents());
+  assert(m.extents() == e);
+
+  // check required_span_size()
+  typename E::index_type expected_size = 1;
+  for (typename E::rank_type r = 0; r < E::rank(); r++)
+    expected_size *= e.extent(r);
+  assert(m.required_span_size() == expected_size);
+}
+
+constexpr bool test() {
+  constexpr size_t D = std::dynamic_extent;
+  test_construction(std::extents<int>());
+  test_construction(std::extents<unsigned, D>(7));
+  test_construction(std::extents<unsigned, 7>());
+  test_construction(std::extents<unsigned, 7, 8>());
+  test_construction(std::extents<int64_t, D, 8, D, D>(7, 9, 10));
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/ctor.mapping.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// template<class OtherExtents>
+//   constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+//     mapping(const mapping<OtherExtents>&) noexcept;
+
+// Constraints: is_constructible_v<extents_type, OtherExtents> is true.
+//
+// Preconditions: other.required_span_size() is representable as a value of type index_type
+
+#include <mdspan>
+#include <type_traits>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+
+template <class To, class From>
+constexpr void test_implicit_conversion(To dest, From src) {
+  assert(dest == src);
+}
+
+template <bool implicit, class ToE, class FromE>
+constexpr void test_conversion(FromE src_exts) {
+  using To   = std::layout_right::mapping<ToE>;
+  using From = std::layout_right::mapping<FromE>;
+  From src(src_exts);
+
+  ASSERT_NOEXCEPT(To(src));
+  To dest(src);
+
+  assert(dest == src);
+  if constexpr (implicit) {
+    dest = src;
+    assert(dest == src);
+    test_implicit_conversion<To, From>(src, src);
+  }
+}
+
+template <class T1, class T2>
+constexpr void test_conversion() {
+  constexpr size_t D = std::dynamic_extent;
+  constexpr bool idx_convertible =
+      static_cast<size_t>(std::numeric_limits<T1>::max()) >= static_cast<size_t>(std::numeric_limits<T2>::max());
+
+  // clang-format off
+  test_conversion<idx_convertible && true,  std::extents<T1>>(std::extents<T2>());
+  test_conversion<idx_convertible && true,  std::extents<T1, D>>(std::extents<T2, D>(5));
+  test_conversion<idx_convertible && false, std::extents<T1, 5>>(std::extents<T2, D>(5));
+  test_conversion<idx_convertible && true,  std::extents<T1, 5>>(std::extents<T2, 5>());
+  test_conversion<idx_convertible && false, std::extents<T1, 5, D>>(std::extents<T2, D, D>(5, 5));
+  test_conversion<idx_convertible && true,  std::extents<T1, D, D>>(std::extents<T2, D, D>(5, 5));
+  test_conversion<idx_convertible && true,  std::extents<T1, D, D>>(std::extents<T2, D, 7>(5));
+  test_conversion<idx_convertible && true,  std::extents<T1, 5, 7>>(std::extents<T2, 5, 7>());
+  test_conversion<idx_convertible && false, std::extents<T1, 5, D, 8, D, D>>(std::extents<T2, D, D, 8, 9, 1>(5, 7));
+  test_conversion<idx_convertible && true,  std::extents<T1, D, D, D, D, D>>(
+                                            std::extents<T2, D, D, D, D, D>(5, 7, 8, 9, 1));
+  test_conversion<idx_convertible && true,  std::extents<T1, D, D, 8, 9, D>>(std::extents<T2, D, 7, 8, 9, 1>(5));
+  test_conversion<idx_convertible && true,  std::extents<T1, 5, 7, 8, 9, 1>>(std::extents<T2, 5, 7, 8, 9, 1>());
+  // clang-format on
+}
+
+template <class IdxT, size_t... Extents>
+using mapping_t = typename std::layout_right::template mapping<std::extents<IdxT, Extents...>>;
+
+constexpr void test_no_implicit_conversion() {
+  constexpr size_t D = std::dynamic_extent;
+
+  // Sanity check that one static to dynamic conversion works
+  static_assert(std::is_constructible_v<mapping_t<int, D>, mapping_t<int, 5>>);
+  static_assert(std::is_convertible_v<mapping_t<int, 5>, mapping_t<int, D>>);
+
+  // Check that dynamic to static conversion only works explicitly
+  static_assert(std::is_constructible_v<mapping_t<int, 5>, mapping_t<int, D>>);
+  static_assert(!std::is_convertible_v<mapping_t<int, D>, mapping_t<int, 5>>);
+
+  // Sanity check that one static to dynamic conversion works
+  static_assert(std::is_constructible_v<mapping_t<int, D, 7>, mapping_t<int, 5, 7>>);
+  static_assert(std::is_convertible_v<mapping_t<int, 5, 7>, mapping_t<int, D, 7>>);
+
+  // Check that dynamic to static conversion only works explicitly
+  static_assert(std::is_constructible_v<mapping_t<int, 5, 7>, mapping_t<int, D, 7>>);
+  static_assert(!std::is_convertible_v<mapping_t<int, D, 7>, mapping_t<int, 5, 7>>);
+
+  // Sanity check that smaller index_type to larger index_type conversion works
+  static_assert(std::is_constructible_v<mapping_t<size_t, 5>, mapping_t<int, 5>>);
+  static_assert(std::is_convertible_v<mapping_t<int, 5>, mapping_t<size_t, 5>>);
+
+  // Check that larger index_type to smaller index_type conversion works explicitly only
+  static_assert(std::is_constructible_v<mapping_t<int, 5>, mapping_t<size_t, 5>>);
+  static_assert(!std::is_convertible_v<mapping_t<size_t, 5>, mapping_t<int, 5>>);
+}
+
+constexpr void test_rank_mismatch() {
+  constexpr size_t D = std::dynamic_extent;
+
+  static_assert(!std::is_constructible_v<mapping_t<int, D>, mapping_t<int>>);
+  static_assert(!std::is_constructible_v<mapping_t<int>, mapping_t<int, D, D>>);
+  static_assert(!std::is_constructible_v<mapping_t<int, D>, mapping_t<int, D, D>>);
+  static_assert(!std::is_constructible_v<mapping_t<int, D, D, D>, mapping_t<int, D, D>>);
+}
+
+constexpr void test_static_extent_mismatch() {
+  constexpr size_t D = std::dynamic_extent;
+
+  static_assert(!std::is_constructible_v<mapping_t<int, D, 5>, mapping_t<int, D, 4>>);
+  static_assert(!std::is_constructible_v<mapping_t<int, 5>, mapping_t<int, 4>>);
+  static_assert(!std::is_constructible_v<mapping_t<int, 5, D>, mapping_t<int, 4, D>>);
+}
+
+constexpr bool test() {
+  test_conversion<int, int>();
+  test_conversion<int, size_t>();
+  test_conversion<size_t, int>();
+  test_conversion<size_t, long>();
+  test_no_implicit_conversion();
+  test_rank_mismatch();
+  test_static_extent_mismatch();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/extents.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// template<class Extents>
+// class layout_left::mapping;
+
+// If Extents is not a specialization of extents, then the program is
+// ill-formed.
+
+// Mandates: If Extents::rank_dynamic() == 0 is true, then the size of the
+// multidimensional index space Extents() is representable as a value of type
+// typename Extents::index_type.
+
+#include <mdspan>
+
+void not_extents() {
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}layout_right::mapping template argument must be a specialization of extents}}
+  [[maybe_unused]] std::layout_right::mapping<void> mapping;
+}
+
+void representable() {
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}layout_right::mapping product of static extents must be representable as index_type.}}
+  [[maybe_unused]] std::layout_right::mapping<std::extents<char, 20, 20>> mapping;
+}

libcxx/test/std/containers/views/mdspan/layout_right/index_operator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// Test default iteration:
+//
+// template<class... Indices>
+//   constexpr index_type operator()(Indices...) const noexcept;
+//
+// Constraints:
+//   * sizeof...(Indices) == extents_type::rank() is true,
+//   * (is_convertible_v<Indices, index_type> && ...) is true, and
+//   * (is_nothrow_constructible_v<index_type, Indices> && ...) is true.
+//
+// Preconditions:
+//   * extents_type::index-cast(i) is a multidimensional index in extents_.
+
+#include <mdspan>
+#include <cassert>
+#include <cstdint>
+
+#include "test_macros.h"
+
+#include "../ConvertibleToIntegral.h"
+
+template<class Mapping, class ... Indices>
+concept operator_constraints = requires(Mapping m, Indices ... idxs) {
+  {std::is_same_v<decltype(m(idxs...)), typename Mapping::index_type>};
+};
+
+template<class Mapping, class ... Indices>
+  requires(
+    operator_constraints<Mapping, Indices...>
+  )
+constexpr bool check_operator_constraints(Mapping m, Indices ... idxs) {
+  (void) m(idxs...);
+  return true;
+}
+
+template<class Mapping, class ... Indices>
+constexpr bool check_operator_constraints(Mapping, Indices ...) {
+  return false;
+}
+
+template <class M, class T, class... Args>
+constexpr void iterate_right(M m, T& count, Args... args) {
+  constexpr size_t r = sizeof...(Args);
+  if constexpr (M::extents_type::rank() == r) {
+    ASSERT_NOEXCEPT(m(args...));
+    assert(count == m(args...));
+    count++;
+  } else {
+    for (typename M::index_type i = 0; i < m.extents().extent(r); i++) {
+      iterate_right(m, count, args..., i);
+    }
+  }
+}
+
+template <class E, class... Args>
+constexpr void test_iteration(Args... args) {
+  using M = std::layout_right::mapping<E>;
+  M m(E(args...));
+
+  typename E::index_type count = 0;
+  iterate_right(m, count);
+}
+
+constexpr bool test() {
+  constexpr size_t D = std::dynamic_extent;
+  test_iteration<std::extents<int>>();
+  test_iteration<std::extents<unsigned, D>>(1);
+  test_iteration<std::extents<unsigned, D>>(7);
+  test_iteration<std::extents<unsigned, 7>>();
+  test_iteration<std::extents<unsigned, 7, 8>>();
+  test_iteration<std::extents<char, D, D, D, D>>(1, 1, 1, 1);
+
+  // Check operator constraint for number of arguments
+  static_assert(check_operator_constraints(std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(1)), 0));
+  static_assert(!check_operator_constraints(std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(1)), 0, 0));
+
+  // Check operator constraint for convertibility of arguments to index_type
+  static_assert(check_operator_constraints(std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(1)), IntType(0)));
+  static_assert(!check_operator_constraints(std::layout_right::mapping<std::extents<unsigned, D>>(std::extents<unsigned, D>(1)), IntType(0)));
+
+  // Check operator constraint for no-throw-constructibility of index_type from arguments
+  static_assert(!check_operator_constraints(std::layout_right::mapping<std::extents<unsigned char, D>>(std::extents<unsigned char, D>(1)), IntType(0)));
+
+  return true;
+}
+
+constexpr bool test_large() {
+  constexpr size_t D = std::dynamic_extent;
+  test_iteration<std::extents<int64_t, D, 8, D, D>>(7, 9, 10);
+  test_iteration<std::extents<int64_t, D, 8, 1, D>>(7, 10);
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  // The large test iterates over ~10k loop indices.
+  // With assertions enabled this triggered the maximum default limit
+  // for steps in consteval expressions. Assertions roughly double the
+  // total number of instructions, so this was already close to the maximum.
+  test_large();
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/properties.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// namespace std {
+//   template<class Extents>
+//   class layout_right::mapping {
+//
+//     ...
+//     static constexpr bool is_always_unique() noexcept { return true; }
+//     static constexpr bool is_always_exhaustive() noexcept { return true; }
+//     static constexpr bool is_always_strided() noexcept { return true; }
+//
+//     static constexpr bool is_unique() noexcept { return true; }
+//     static constexpr bool is_exhaustive() noexcept { return true; }
+//     static constexpr bool is_strided() noexcept { return true; }
+//     ...
+//   };
+// }
+
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class E>
+constexpr void test_layout_mapping_right() {
+  using M = std::layout_right::template mapping<E>;
+  assert(M::is_unique() == true);
+  assert(M::is_exhaustive() == true);
+  assert(M::is_strided() == true);
+  assert(M::is_always_unique() == true);
+  assert(M::is_always_exhaustive() == true);
+  assert(M::is_always_strided() == true);
+  ASSERT_NOEXCEPT(std::declval<M>().is_unique());
+  ASSERT_NOEXCEPT(std::declval<M>().is_exhaustive());
+  ASSERT_NOEXCEPT(std::declval<M>().is_strided());
+  ASSERT_NOEXCEPT(M::is_always_unique());
+  ASSERT_NOEXCEPT(M::is_always_exhaustive());
+  ASSERT_NOEXCEPT(M::is_always_strided());
+}
+
+constexpr bool test() {
+  constexpr size_t D = std::dynamic_extent;
+  test_layout_mapping_right<std::extents<int>>();
+  test_layout_mapping_right<std::extents<char, 4, 5>>();
+  test_layout_mapping_right<std::extents<unsigned, D, 4>>();
+  test_layout_mapping_right<std::extents<size_t, D, D, D, D>>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/required_span_size.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// constexpr index_type required_span_size() const noexcept;
+//
+// Returns: extents().fwd-prod-of-extents(extents_type::rank()).
+
+
+#include <mdspan>
+#include <cassert>
+#include <cstdint>
+
+#include "test_macros.h"
+
+template <class E>
+constexpr void test_required_span_size(E e, typename E::index_type expected_size) {
+  using M = std::layout_right::mapping<E>;
+  const M m(e);
+
+  ASSERT_NOEXCEPT(m.required_span_size());
+  assert(m.required_span_size() == expected_size);
+}
+
+constexpr bool test() {
+  constexpr size_t D = std::dynamic_extent;
+  test_required_span_size(std::extents<int>(), 1);
+  test_required_span_size(std::extents<unsigned, D>(0), 0);
+  test_required_span_size(std::extents<unsigned, D>(1), 1);
+  test_required_span_size(std::extents<unsigned, D>(7), 7);
+  test_required_span_size(std::extents<unsigned, 7>(), 7);
+  test_required_span_size(std::extents<unsigned, 7, 8>(), 56);
+  test_required_span_size(std::extents<int64_t, D, 8, D, D>(7, 9, 10), 5040);
+  test_required_span_size(std::extents<int64_t, 1, 8, D, D>(9, 10), 720);
+  test_required_span_size(std::extents<int64_t, 1, 0, D, D>(9, 10), 0);
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/static_requirements.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// A type M meets the layout mapping requirements if
+//    - M models copyable and equality_comparable,
+//    - is_nothrow_move_constructible_v<M> is true,
+//    - is_nothrow_move_assignable_v<M> is true,
+//    - is_nothrow_swappable_v<M> is true, and
+//
+// the following types and expressions are well-formed and have the specified semantics.
+//
+//  typename M::extents_type
+//    Result: A type that is a specialization of extents.
+//
+//  typename M::index_type
+//    Result: typename M::extents_type::index_type.
+//
+//  typename M::rank_type
+//    Result: typename M::extents_type::rank_type.
+//
+//  typename M::layout_type
+//    Result: A type MP that meets the layout mapping policy requirements ([mdspan.layout.policy.reqmts]) and for which is-mapping-of<MP, M> is true.
+//
+//  m.extents()
+//    Result: const typename M::extents_type&
+//
+//  m(i...)
+//    Result: typename M::index_type
+//    Returns: A nonnegative integer less than numeric_limits<typename M::index_type>::max() and less than or equal to numeric_limits<size_t>::max().
+//
+//  m(i...) == m(static_cast<typename M::index_type>(i)...)
+//    Result: bool
+//    Returns: true
+//
+//  m.required_span_size()
+//    Result: typename M::index_type
+//    Returns: If the size of the multidimensional index space m.extents() is 0, then 0, else 1 plus the maximum value of m(i...) for all i.
+//
+//  m.is_unique()
+//    Result: bool
+//    Returns: true only if for every i and j where (i != j || ...) is true, m(i...) != m(j...) is true.
+//
+//  m.is_exhaustive()
+//    Result: bool
+//    Returns: true only if for all k in the range [0, m.required_span_size()) there exists an i such that m(i...) equals k.
+//
+//  m.is_strided()
+//    Result: bool
+//    Returns: true only if for every rank index r of m.extents() there exists an integer
+//             sr such that, for all i where (i+dr) is a multidimensional index in m.extents() ([mdspan.overview]),
+//             m((i + dr)...) - m(i...) equals sr
+//
+//  m.stride(r)
+//    Preconditions: m.is_strided() is true.
+//    Result: typename M::index_type
+//    Returns: sr as defined in m.is_strided() above.
+//
+//  M::is_always_unique()
+//    Result: A constant expression ([expr.const]) of type bool.
+//    Returns: true only if m.is_unique() is true for all possible objects m of type M.
+//
+//  M::is_always_exhaustive()
+//    Result: A constant expression ([expr.const]) of type bool.
+//    Returns: true only if m.is_exhaustive() is true for all possible objects m of type M.
+//
+//  M::is_always_strided()
+//    Result: A constant expression ([expr.const]) of type bool.
+//    Returns: true only if m.is_strided() is true for all possible objects m of type M.
+
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+// Common requirements of all layout mappings
+template <class M, size_t... Idxs>
+void test_mapping_requirements(std::index_sequence<Idxs...>) {
+  using E = typename M::extents_type;
+  static_assert(std::__mdspan_detail::__is_extents_v<E>);
+  static_assert(std::is_copy_constructible_v<M>);
+  static_assert(std::is_nothrow_move_constructible_v<M>);
+  static_assert(std::is_nothrow_move_assignable_v<M>);
+  static_assert(std::is_nothrow_swappable_v<M>);
+  ASSERT_SAME_TYPE(typename M::index_type, typename E::index_type);
+  ASSERT_SAME_TYPE(typename M::size_type, typename E::size_type);
+  ASSERT_SAME_TYPE(typename M::rank_type, typename E::rank_type);
+  ASSERT_SAME_TYPE(typename M::layout_type, std::layout_right);
+  ASSERT_SAME_TYPE(typename M::layout_type::template mapping<E>, M);
+  static_assert(std::is_same_v<decltype(std::declval<M>().extents()), const E&>);
+  static_assert(std::is_same_v<decltype(std::declval<M>()(Idxs...)), typename M::index_type>);
+  static_assert(std::is_same_v<decltype(std::declval<M>().required_span_size()), typename M::index_type>);
+  static_assert(std::is_same_v<decltype(std::declval<M>().is_unique()), bool>);
+  static_assert(std::is_same_v<decltype(std::declval<M>().is_exhaustive()), bool>);
+  static_assert(std::is_same_v<decltype(std::declval<M>().is_strided()), bool>);
+  if constexpr (E::rank() > 0)
+    static_assert(std::is_same_v<decltype(std::declval<M>().stride(0)), typename M::index_type>);
+  static_assert(std::is_same_v<decltype(M::is_always_unique()), bool>);
+  static_assert(std::is_same_v<decltype(M::is_always_exhaustive()), bool>);
+  static_assert(std::is_same_v<decltype(M::is_always_strided()), bool>);
+}
+
+template <class L, class E>
+void test_layout_mapping_requirements() {
+  using M = typename L::template mapping<E>;
+  test_mapping_requirements<M>(std::make_index_sequence<E::rank()>());
+}
+
+template <class E>
+void test_layout_mapping_right() {
+  test_layout_mapping_requirements<std::layout_right, E>();
+}
+
+int main(int, char**) {
+  constexpr size_t D = std::dynamic_extent;
+  test_layout_mapping_right<std::extents<int>>();
+  test_layout_mapping_right<std::extents<char, 4, 5>>();
+  test_layout_mapping_right<std::extents<unsigned, D, 4>>();
+  test_layout_mapping_right<std::extents<size_t, D, D, D, D>>();
+  return 0;
+}

libcxx/test/std/containers/views/mdspan/layout_right/stride.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <mdspan>
+
+// constexpr index_type stride(rank_type i) const noexcept;
+//
+//   Constraints: extents_type::rank() > 0 is true.
+//
+//   Preconditions: i < extents_type::rank() is true.
+//
+//   Returns: extents().rev-prod-of-extents(i).
+
+#include <mdspan>
+#include <cassert>
+#include <array>
+#include <cstdint>
+#include <cstdio>
+#include "test_macros.h"
+
+template <class E, class... Args>
+constexpr void test_stride(std::array<typename E::index_type, E::rank()> strides, Args... args) {
+  using M = std::layout_right::mapping<E>;
+  M m(E(args...));
+
+  ASSERT_NOEXCEPT(m.stride(0));
+  for (size_t r = 0; r < E::rank(); r++)
+    assert(strides[r] == m.stride(r));
+}
+
+constexpr bool test() {
+  constexpr size_t D = std::dynamic_extent;
+  test_stride<std::extents<unsigned, D>>(std::array<unsigned, 1>{1}, 7);
+  test_stride<std::extents<unsigned, 7>>(std::array<unsigned, 1>{1});
+  test_stride<std::extents<unsigned, 7, 8>>(std::array<unsigned, 2>{8, 1});
+  test_stride<std::extents<int64_t, D, 8, D, D>>(std::array<int64_t, 4>{720, 90, 10, 1}, 7, 9, 10);
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}