[libcxx] Add mdspan/extents

[crtrott]

Summary

This patch adds std::extents. extents is one of the core classes used by std::mdspan. It describes a multi-dimensional index space with a mix of compile time and runtime sizes. Furthermore, it is templated on the index type used to describe the multi-dimensional index space.

The class is designed to be highly optimizable in performance critical code sections, and is fully useable in constant expressions contexts.

Testing of this class tends to be somewhat combinatorical, due to the large number of possible corner cases involved in situations where we have both runtime and compile time extents. To add to this, the class is designed to be interoperable (in particular constructible) from arguments which only need to be convertible to the index_type, but are otherwise arbitrary user types. For a larger discussion on the design of this class refer to: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0009r18.html

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

[dalg24]

More fiddling with the CI by Christian

[dalg24]

Fix module map

[dalg24]

Fiddling with header includes to fix modular tests and qualify std::size_t in tests

[crtrott]

This is ready for review together with the child revision which fixes a few leftover issues flagged by the CI (missing updates in transitive include files, and ABI hiding macros).

[crtrott]

Note the revision D148448 did pass the second stage CI testing (GCC 12, C++2b, Modules, C++11, C++03)

[crtrott]

I will update this revision with fixes for CI

[crtrott]

Fixed transitive includes, ABI hiding, and windows excluding assert test.

[Mordante]

I have mainly looked at the libc++ style and not too deeply at the code itself. I saw @ldionne wanted to do a live review so I leave the detailed review to him.

libcxx/include/__mdspan/extents.h

414

Since the paper has been accepted for C++23 I would prefer to remove this comment and use the optimal version for C++23.

418

We typically only qualify function calls, since they maybe affected by ADL. There is a CI job that tests function calls are indeed qualified, much like the CI job that tests for _LIBCPP_HIDE_FROM_ABI.

470–477

I wonder whether the true branch should just be return false and reduce the scope of __value. LLVM has no single entry single exit requirement. WDYT?

482

Is this really in the Standard? Is it not automatically generated from operator== ?

If so, and you know why, can you add that information as comment?

libcxx/include/mdspan

24–31

We typically omit that for toplevel headers that only include their subheaders.

libcxx/test/libcxx/clang_tidy.sh.cpp

142 ↗

(On Diff #514637)

When starting a new feature we typically add its feature-test macro to
libcxx/utils/generate_feature_test_macro_components.py with a "unimplemented": True, entry.

Note after that change you need to regenerate the libc++ files.

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

16

If operator!= is not generated by the compiler can you add it here too?

libcxx/test/std/containers/views/mdspan/extents/cons.fail.cpp

56

Then (void)e1 is no longer needed.

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

155

Is this test the same as the previous but only testing the constant evaluation?

If so we typically use a different pattern

constexpr bool test(){
  // test stuff

  return true;
}

int main(int const char**) {
  test();
  static_assert(test());
}

For example look at libcxx/test/std/utilities/format/format.syn/format_to_n_result.pass.cpp.

[crtrott]

libcxx/include/__mdspan/extents.h

414

Yeah we can do that.

418

ok will remove.

470–477

Essentially we had issues with NVC++ and NVCC which would warn about missing return statements if you just return inside the if constexpr clauses.

482

Yeah actually we can remove this. C++20 onwards doesn't require it.

libcxx/include/mdspan

24–31

Will do

libcxx/test/libcxx/clang_tidy.sh.cpp

142 ↗

(On Diff #514637)

will do

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

16

It is.

libcxx/test/std/containers/views/mdspan/extents/cons.fail.cpp

56

will do

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

155

Its not quite the same. Specifically the other test will assert individually on the extents paramemters matching, while this one just gives a grand total. So you wouldn't get an immediate feedback which thing exactly went wrong

[crtrott]

Addressed Mordante's review comments:

• removed C++14 back port code path
• removed unnecessary class namespace qualification
• removed unnecessary operator !=
• removed unnecessary macro stuff in mdspan header
• added feature test macro
• used [[maybe_unused]] instead of (void)

[crtrott]

Add missing generated file

[ldionne]

Thank you so much for the patch! Leaving my comments from our live review.

libcxx/include/__mdspan/extents.h

21

This should go in <mdspan> instead. Note that we're discussing whether we even want to keep writing synopsis, but for the time being let's assume we will and do it consistently with the other headers.

148

149

I think this is equivalent (https://godbolt.org/z/8K9ds9Tej):

template <class _Tp, _Tp... _Values>
struct __static_array {
  static constexpr array<_Tp, sizeof...(_Values)> __array = {_Values...};

public:
  _LIBCPP_HIDE_FROM_ABI constexpr static size_t __size() { return sizeof...(_Values); }
  _LIBCPP_HIDE_FROM_ABI constexpr static _Tp __get(size_t __index) noexcept { return __array[__index]; }

  template <size_t _Index>
  _LIBCPP_HIDE_FROM_ABI constexpr static _Tp __get() { return __get(_Index); }
};

It's a bit simpler and should result in fewer instantiations.

176–191

I think we can simplify this one as well for a bit more compile-time win (https://godbolt.org/z/qjn471871):

template <std::size_t ..._Values>
_LIBCPP_HIDE_FROM_ABI constexpr array<size_t, sizeof...(_Values)> __partial_sums_impl() {
  array<size_t, sizeof...(_Values)> __values = {_Values...};
  array<size_t, sizeof...(_Values)> __partial_sums;
  size_t __running_sum = 0;
  for (int __i = 0; __i != __values.size(); ++__i) {
    __partial_sums[__i] = __running_sum;
    __running_sum += __values[__i];
  }
  return __partial_sums;
}

template <size_t ..._Values>
struct __partial_sums {
  static constexpr array<size_t, sizeof...(_Values)> __result = __partial_sums_impl<_Values...>();

  _LIBCPP_HIDE_FROM_ABI constexpr static size_t __get(size_t __index) {
    return __result[__index];
  }
};

202

205

Throughout?

211–212

I think that expresses your intent better, since this is really never called.

232

Or something else that doesn't have _t as a suffix. I'm not strongly attached, but we try not to use _t for typedefs (you can find some places in our code where we don't follow that, of course).

247–249

This is a workaround for the 0 case, and I don't think it's needed. What's the issue you are seeing if you remove the workaround? I would guess it's only a GCC issue since you mentioned it was some sort of tautological-comparison warning?

257

At the end of the day, we have the following constructors:

1. Variadic / only initialize dynamic extents
2. Variadic / initialize everything
3. std::span / only initialize dynamic extents
4. std::span / initialize everything

For this implementation-detail class, I would introduce two tag types to make it very obvious what's going on:

struct __initialize_dynamic_extents_t { };
struct __initialize_all_extents_t { };

 template <class ..._Vals>
_LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(__initialize_dynamic_extents_t , Vals ...__vals)
      : __dyn_vals_{static_cast<_TDynamic>(__vals)...} {}

 template <class ..._Vals>
_LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(__initialize_all_extents_t , Vals ...__vals) {
    static_assert((sizeof...(_DynVals) == __size_), "Invalid number of values.");
    _TDynamic __values[__size_]{static_cast<_TDynamic>(__vals)...};
    // etc...
}

// and then the same for the `std::span` version

In particular, I would remove the requires from these constructors here and go for more explicit and dumber constructors. The requires can then be left on the actual public APIs in std::extents below. From std::extents, you'd then use:

template <class... _OtherIndexTypes>
    requires(existing-logic-from-the-standard-and-nothing-more)
_LIBCPP_HIDE_FROM_ABI constexpr explicit extents(_OtherIndexTypes... __dynvals) noexcept
      : __vals_(conditional_t<sizeof...(_OtherIndexTypes) == __size_dynamic_, __initialize_dynamic_extents_t, __initialize_all_extents_t>{},
             static_cast<index_type>(__dynvals)...) {}

Suggestion: Try to remove the workaround for the 0 case above, and then let's see whether the contents of the requires are still hard to parse. So maybe don't do anything about this issue for now.

367–368

Throughout: we use static constexpr instead of constexpr static. It's a nitpick, but let's do it for consistency.

@philnik In case you are looking to add more clang-tidy checks, maybe that's one we could have.

371

Similarly here, I guess.

376

Please make sure that you have tests that check ASSERT_NOEXCEPT for all these methods. If you have some, just verify and mark the comment as done!

393

I would like for the preconditions in https://eel.is/c++draft/views.multidim#mdspan.extents.cons-7 (and friends) to be checked. Furthermore, and you might find it a bit nitpicky, please add a assert.foo.pass.cpp test that confirms that we crash when the preconditions are violated.

396–401

Then we can have only two constructors in the implementation-detail constructors: one with span, and a variadic one.

408

We shouldn't be std::moveing here.

412

I think there's a way to do this without recursion and without requiring multiple loops initializing the dynamic values, but I cant see it right now. Leaving a note to look again.

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

10

Let's make this TEST_STD_CONTAINERS_xxxxxxx etc.

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

17–20 ↗

(On Diff #515207)

These remarks are not necessary here IMO, but I would probably list the preconditions you're testing somewhere.

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

81

We need to test all of this at constexpr and non-constexpr. You can see how we generally do this here, it's pretty easy: libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp.

libcxx/test/std/containers/views/mdspan/extents/cons.fail.cpp

2

This should be moved to the cons.pass.cpp test, and we should verify that those ctors SFINAE away using requires instead. For example, something like this:

template <class ...Args>
concept ExtentsConstructible = requires (Args ...args) {
  std::extents<????>(args...);
};

static_assert(!ExtentsConstructible<...>);

Or you could just test !std::is_constructible<std::extents<...>, ...>, we do that in a bunch of places.

Rationale: these clang-verify tests are more fragile to diagnostic wording changing, and we really want to allow checking that on all supported compilers, not only Clang. Also, it allows other stdlibs to benefit from these tests.

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

2

Let's rename this to ctor.pass.cpp.

13

Please make sure you test one overload per .pass.cpp file. You can use a header file in this subdirectory to avoid creating a bunch of duplication.

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

155

I would instead make sure that all the other tests are checked in constexpr and non-constexpr, and then drop this test.

libcxx/test/std/containers/views/mdspan/extents/conversion.fail.cpp

2

Same here for SFINAE.

[crtrott]

This implements feedback from review by @ldionne

Changes to extents.h

• add check for extents parameter being representable as index_type
  • adds both the mandate for the template parameters, and precondition checks for constructors
• add precondition check on extent/static_extent for r being < rank()
• use simpler static_array impl
• use simpler implementation for static scan, now called static_partial_sums
• simplify constructors for __maybe_static_array
  • removed from array constructors (i.e. extents passes on a span)
  • implement zero length case via if constexpr in ctor body instead of different overloads
• rename a few variables based on comments (i, r, static_vals_t, dyn_map_t, _Num)
• fix order for constexpr static
• move synopsis to mdspan header
• fix default constructor not zero initializing dynamic values
  • this required a few little helper things to zero init __possibly_empty_array

Changes to tests

• rework constructor tests to test one overload per cpp
  • use header file for common code to implement combinatorial testing
• add test for default constructor
• rewrite tests for non-allowed construction to use traits instead of failing compile
• rewrite conversion tests to use traits to check for illegal conversions instead of fail test
• add assert tests to test for all possible precondition violations
• update comment in tests to have the definition from the standard in each header for what gets tested.

[tschuett]

libcxx/include/__mdspan/extents.h

13

Disclaimer: I am not a lawyer. The copyright notice might confuse vendors shipping libc++ or stop them to.

[crtrott]

Ticket off a bunch of comments as done. Looks like the only outstanding comment is that some tests don't test constexpr yet (e.g. comparison).

libcxx/include/__mdspan/extents.h

176–191

Turns out I run into issues for rank-0 extents. However, using __possibly_empty_array instead of std::array here makes it work. https://godbolt.org/z/1Tona7Mzz

211–212

I used __libcpp_unreachable looked like that was the common practice in these headers.

257

I removed the from array constructor, implemented the zero case via constexpr if in the body instead of different overloads

[crtrott]

libcxx/include/__mdspan/extents.h

13

I believe this is ok. The LLVM guidelines explicitly state that copyright is held by contributors.

The LLVM project does not collect copyright assignments, which means that the copyright for the code in the project is held by the respective contributors. Because you (or your company) retain ownership of the code you contribute, you know it may only be used under the terms of the open source license you contributed it under: the license for your contributions cannot be changed in the future without your approval.

Because the LLVM project does not require copyright assignments, changing the LLVM license requires tracking down the contributors to LLVM and getting them to agree that a license change is acceptable for their contributions. We feel that a high burden for relicensing is good for the project, because contributors do not have to fear that their code will be used in a way with which they disagree.

My understanding of the llvm exceptions in the License is that this copyright notice does not need to be reproduced by folks shipping compiled stuff. And if they ship the source they distribute this copyright notice implicitly so its fine. Note the original code where this Copyright is coming from is licensed under the exact same terms, including the LLVM exceptions.

Note also that LIBCXX already contains a bunch of Copyright notices. There are a whole lot from Microsoft which even say "All rights reserved" not just "certain rights", and Copyright s from Unicode, Inc. and a few individual folks.

[crtrott]

Screwed up rebase before, so the patch didn't apply cleanly.

[crtrott]

• fix the two stage-2 CI issues observed (missing include, and unused variable)
• make last few tests which weren't yet test constexpr too
  • that found one more constexpr needed inside extents itself

[crtrott]

Looks like we did address all but one comment for the header guard ...

[crtrott]

• update header guard
• update Cxx2bPapers status (mark P0009 mdspan in progress)
• hopefully fix module build

[crtrott]

Fix clang-format.

[crtrott]

Rebase for transitive includes.

[crtrott]

Attempt to fix module based build and transitive includes

[Mordante]

I did another pass over this patch and I have no additional comments.
So no objections from my side to approve this patch when you're happy @ldionne.

[crtrott]

Do not test for is_empty on Windows. Looks like that doesn't work there.

[H-G-Hristov]

libcxx/CREDITS.TXT

195 ↗

(On Diff #518367)

The list is sorted by surname and formatted to allow easy grepping and

It seems you should reorder the list.

[ldionne]

This basically LGTM. I'll take one last look when the comments have been applied and we can ship this. Thanks for the awesome patch!

libcxx/include/__mdspan/extents.h

137

I think I would use _LIBCPP_NO_UNIQUE_ADDRESS here instead.

146

Then you can get rid of __zero above.

173

226

235

std:: qualification here is not necessary, same for index_sequence in a few places.

236

I think that's what you mean.

243

253

255

Since this is not a function, full qualification is not needed. But you want to ADL-proof the calls so you do need one level of qualification. It should look like __mdspan_detail::__is_representable_as<_To>.

261

x2

307

Suggestion: constructors could come first like they do in the spec and like we usually do.

388

Can you confirm that this is optimized away by the compiler by default (assertions are disabled by default)? This should expand to

for (...) {
  if constexpr (make-sure-this-is-true) {
    __builtin_assume(is_representable_as(...));
  }
}

Hopefully this gets optimized out, otherwise I think we have a Clang bug on our hand.

403–410

IMO this is more readable:

using _CommonType = <...>; // nice little comment here explaining why we need this
if constexpr (rank() != sizeof...(_OtherExtents)) {
  return false;
} else {
  for (rank_type __r = 0; __r < __rank_; __r++) {
    if (static_cast<_CommonType>(__lhs.extent(__r)) != static_cast<_CommonType>(__rhs.extent(__r)))
      return false;
  }
}
return true;

libcxx/include/mdspan

48–52

Those are not in this review, right? If so, let's remove them from here.

72–73

I don't think those should be required. You might need to export size_t and span from the mdspan module to get rid of your modular CI issues if that was the problem you were trying to solve.

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

32–37 ↗

(On Diff #518367)

You can just assert(ext.extent(r) == static_cast<typename E::index_type>(expected[r])) here and return void from this function, no?

68–94 ↗

(On Diff #518367)

Here you can just directly call all the test_construction<...> functions without checking for a result.

98 ↗

(On Diff #518367)

This guy needs to just return true unconditionally so you can call it inside a constexpr context.

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

28 ↗

(On Diff #518367)

I think this should be renamed?

35 ↗

(On Diff #518367)

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

40 ↗

(On Diff #518367)

Probably needs a new name too. Please check throughout, I think this is copy/paste.

45–46 ↗

(On Diff #518367)

You don't need to return anything from here too.

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

56–59 ↗

(On Diff #518367)

I would move these tests to their corresponding ctor_<wahtever>.pass.cpp file. We generally have these tests alongside our other runtime tests, since they are not really different from normal tests in any way.

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

15 ↗

(On Diff #518367)

Consider breaking this line.

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

47

Here you want to use LIBCPP_STATIC_ASSERT instead because this is libc++ specific behavior, not something mandated by the standard.

[crtrott]

Address more review comments

• drop unnecessary std qualitication
• update comparison to do early return
• use _LIBCPP_NO_UNIQUE_ADDRESS
• fixup numeric limits use in __is_representable_as
• use common initializer list syntax
• use integral concept to constrain types in representable_as helpers
• use common_type for extent comparison
• drop exposition-only helpers from synopsis
• use simple assert instead bool pass-through returns in tests
• fixup CREDITS.TXT alphabetical order
• move non_constructible test into other ctor tests as appropriate

[crtrott]

Ticked off all the things we actually did, looks like there is a couple left over.

libcxx/include/__mdspan/extents.h

146

Turns out this warns:

llvm-project/build3/include/c++/v1/__mdspan/extents.h:143:28: error: left operand of comma operator has no effect [-Werror,-Wunused-value]
    return _DynamicValues{(Indices, 0)...};

146

n

307

We left it because it feels like the having the immediate accessors next to the variables is more readable.

412

Didn't come up with a way,

[crtrott]

Address last couple comments:

• remove more exposition only from synopsis
• break comment line
• use LIBCPP_STATIC_ASSERT for is_empty check
• remove stray std:: in extents.h

[crtrott]

Marked of remaining comments/questions.

libcxx/include/__mdspan/extents.h

13

Discussed with @ldionne and he agreed this is fine.

388

Yeah this all compiles away see this godbolt link:
https://godbolt.org/z/h5rqEMbcP

If you take the -DNDEBUG away it compiles into some big chunk unless it figures out that nothing bad could possible happen.
All in all this behaves as expected.

Note: the default is that assertions are ON.

[ldionne]

libcxx/include/__mdspan/extents.h

176–191

I just investigated this a bit more. Here's the difference: https://godbolt.org/z/8zsMfzEd9.

The problem is that you had

std::array<std::size_t, sizeof...(_Values)> __partial_sums;

Instead, if you switch to

std::array<std::size_t, sizeof...(_Values)> __partial_sums{};

then your array is value-initialized and it works.

[ldionne]

libcxx/include/__mdspan/extents.h

388

I corrected the godbolt: https://godbolt.org/z/15cbEacW4

My question was specifically about whether _LIBCPP_ASSERT inside the loop was going to get optimized out because it expands to __builtin_assume, and the answer is yes, indeed. Thanks for checking!

[crtrott]

libcxx/include/__mdspan/extents.h

176–191

Ah, makes sense. That said, do you feel we should move back to array instead of possibly_empty_array? I am inclined to leave it as is. If nothing else __possibly_empty_array is a bit simpler than std::array, and thus at the margin it may ease compile time a bit. Thoughts?

[ldionne]

LGTM w/ comments and CI. If some comments can't be applied, please LMK.

Thanks a lot for the contribution and for all the time you devoted during our live reviews!

libcxx/include/__mdspan/extents.h

110

Optional: If you want you could maybe use an immediately invoked lambda here to avoid giving a name to __static_partial_sums_impl, which is obviously just a one-shot helper for now:

static constexpr std::array<size_t, sizeof...(_Values)> __result = []{
  // implementation here
}();

146

return _DynamicValues{((void)Indices, 0)...};

This gets rid of the warning, it's a common trick.

176–191

I think I would go for std::array cause it's more idiomatic and you don't need the properties of maybe_empty_array here. Otherwise it seems like we require the maybe_empty_array when we don't, which is a bit confusing.

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

23

Nit for consistency: // TEST_STD_CONTAINERS_CONVERTIBLE_TO_INTEGRAL_H

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

11–33

There seems to be a copy-paste issue here.

39

Equivalent, but semantically you want to check what the result of != *is*, not what it *isn't*.

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

30–31 ↗

(On Diff #518936)

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

79 ↗

(On Diff #518936)

I think you mean just a regular assert here, since this is not a libc++ extension.

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

60 ↗

(On Diff #518936)

Here's a really annoying one that we don't seem to have clang-tidy checks for. Please make sure you declare main as int main(int, char**) and make sure you return 0; at the end. This is needed for running tests in Freestanding, where main() is not a special function (so no implicit return and no implicit extern "C" mangling).

Please check throughout all your tests.

81 ↗

(On Diff #518936)

Same here, probably assert.

[crtrott]

Addressed last review comments.

[philnik]

libcxx/docs/Status/Cxx2bPapers.csv

54 ↗

(On Diff #522246)

A note listing what is already implemented/what still needs to be implemented would be nice.

[crtrott]

libcxx/docs/Status/Cxx2bPapers.csv

54 ↗

(On Diff #522246)

What do you think of a pinky promise I file a separate change request to update that note, I think @ldionne was otherwise ready to merge this today.

[ldionne]

CI LGTM, I checked and the only failure is a fluke. I'll merge this.

libcxx/docs/Status/Cxx2bPapers.csv

54 ↗

(On Diff #522246)

I'd be fine with that! I am indeed looking forward to shipping this large review.

[philnik]

libcxx/docs/Status/Cxx2bPapers.csv

54 ↗

(On Diff #522246)

Also fine with me.

libcxx/include/CMakeLists.txt

set(files
   __iterator/reverse_iterator.h
   __iterator/segmented_iterator.h
   __iterator/size.h
   __iterator/sortable.h
   __iterator/unreachable_sentinel.h
   __iterator/wrap_iter.h
   __locale
   __mbstate_t.h
+  __mdspan/extents.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
set(files
   libcxx.imp
   limits
   limits.h
   list
   locale
   locale.h
   map
   math.h
+  mdspan
   memory
   memory_resource
   mutex
   new
   numbers
   numeric
   optional
   ostream

libcxx/include/__mdspan/extents.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_EXTENTS
+#define _LIBCPP_EXTENTS
+
+#include <array>
+#include <cinttypes>
+#include <limits>
+#include <span>
+
+#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 > 20
+
+namespace detail {
+
+// ------------------------------------------------------------------
+// ------------ static_array ----------------------------------------
+// ------------------------------------------------------------------
+// array like class which provides an array of static values with get
+
+// Implementation of Static Array with recursive implementation of get.
+template <size_t R, class T, T... Extents>
+struct static_array_impl;
+
+template <size_t R, class T, T FirstExt, T... Extents>
+struct static_array_impl<R, T, FirstExt, Extents...> {
+  constexpr static T get(size_t r) noexcept {
+    if (r == R)
+      return FirstExt;
+    else
+      return static_array_impl<R + 1, T, Extents...>::get(r);
+  }
+  template <size_t r>
+  constexpr static T get() {
+    if constexpr (r == R)
+      return FirstExt;
+    else
+      return static_array_impl<R + 1, T, Extents...>::template get<r>();
+  }
+};
+
+// End the recursion
+template <size_t R, class T, T FirstExt>
+struct static_array_impl<R, T, FirstExt> {
+  constexpr static T get(size_t) noexcept { return FirstExt; }
+  template <size_t>
+  constexpr static T get() {
+    return FirstExt;
+  }
+};
+
+// Don't start recursion if size 0
+template <class T>
+struct static_array_impl<0, T> {
+  constexpr static T get(size_t) noexcept { return T(); }
+  template <size_t>
+  constexpr static T get() {
+    return T();
+  }
+};
+
+// Static array, provides get<r>(), get(r) and operator[r]
+template <class T, T... Values>
+struct static_array : public static_array_impl<0, T, Values...> {
+public:
+  using value_type = T;
+
+  constexpr static size_t size() { return sizeof...(Values); }
+};
+
+// ------------------------------------------------------------------
+// ------------ index_sequence_scan ---------------------------------
+// ------------------------------------------------------------------
+
+// index_sequence_scan takes compile time values and provides get(r)
+//  which return the sum of the first r-1 values.
+
+// Recursive implementation for get
+template <size_t R, size_t... Values>
+struct index_sequence_scan_impl;
+
+template <size_t R, size_t FirstVal, size_t... Values>
+struct index_sequence_scan_impl<R, FirstVal, Values...> {
+  constexpr static size_t get(size_t r) {
+    if (r > R)
+      return FirstVal + index_sequence_scan_impl<R + 1, Values...>::get(r);
+    else
+      return 0;
+  }
+};
+
+template <size_t R, size_t FirstVal>
+struct index_sequence_scan_impl<R, FirstVal> {
+#  if defined(__NVCC__) || defined(__NVCOMPILER)
+  // NVCC warns about pointless comparison with 0 for R==0 and r being const
+  // evaluatable and also 0.
+  constexpr static size_t get(size_t r) { return static_cast<int64_t>(R) > static_cast<int64_t>(r) ? FirstVal : 0; }
+#  else
+  constexpr static size_t get(size_t r) { return R > r ? FirstVal : 0; }
+#  endif
+};
+template <>
+struct index_sequence_scan_impl<0> {
+  constexpr static size_t get(size_t) { return 0; }
+};
+
+// ------------------------------------------------------------------
+// ------------ possibly_empty_array  -------------------------------
+// ------------------------------------------------------------------
+
+// array like class which provides get function and operator [], and
+// has a specialization for the size 0 case.
+// This is needed to make the maybe_static_array be truly empty, for
+// all static values.
+
+template <class T, size_t N>
+struct possibly_empty_array {
+  T vals[N];
+  constexpr T& operator[](size_t r) { return vals[r]; }
+  constexpr const T& operator[](size_t r) const { return vals[r]; }
+};
+
+template <class T>
+struct possibly_empty_array<T, 0> {
+  constexpr T operator[](size_t) { return T(); }
+  constexpr const T operator[](size_t) const { return T(); }
+};
+
+// ------------------------------------------------------------------
+// ------------ maybe_static_array ----------------------------------
+// ------------------------------------------------------------------
+
+// array like class which has a mix of static and runtime values but
+// only stores the runtime values.
+// The type of the static and the runtime values can be different.
+// The position of a dynamic value is indicated through a tag value.
+template <class TDynamic, class TStatic, TStatic dyn_tag, TStatic... Values>
+struct maybe_static_array {
+  static_assert(is_convertible<TStatic, TDynamic>::value,
+                "maybe_static_array: TStatic must be convertible to TDynamic");
+  static_assert(is_convertible<TDynamic, TStatic>::value,
+                "maybe_static_array: TDynamic must be convertible to TStatic");
+
+private:
+  // Static values member
+  using static_vals_t                    = static_array<TStatic, Values...>;
+  constexpr static size_t m_size         = sizeof...(Values);
+  constexpr static size_t m_size_dynamic = ((Values == dyn_tag) + ... + 0);
+
+  // Dynamic values member
+  [[no_unique_address]] possibly_empty_array<TDynamic, m_size_dynamic> m_dyn_vals;
+
+  // static mapping of indices to the position in the dynamic values array
+  using dyn_map_t = index_sequence_scan_impl<0, static_cast<size_t>(Values == dyn_tag)...>;
+
+public:
+  // two types for static and dynamic values
+  using value_type        = TDynamic;
+  using static_value_type = TStatic;
+  // tag value indicating dynamic value
+  constexpr static static_value_type tag_value = dyn_tag;
+
+  constexpr maybe_static_array() = default;
+
+  // constructor for all static values
+  // TODO: add precondition check?
+  template <class... Vals>
+    requires((m_size_dynamic == 0) && (sizeof...(Vals) > 0))
+  constexpr maybe_static_array(Vals...) : m_dyn_vals{} {}
+
+  // constructors from dynamic values only
+  template <class... DynVals>
+    requires(sizeof...(DynVals) == m_size_dynamic && m_size_dynamic > 0)
+  constexpr maybe_static_array(DynVals... vals) : m_dyn_vals{static_cast<TDynamic>(vals)...} {}
+
+  template <class T, size_t N>
+    requires(N == m_size_dynamic && N > 0)
+  constexpr maybe_static_array(const std::array<T, N>& vals) {
+    for (size_t r = 0; r < N; r++)
+      m_dyn_vals[r] = static_cast<TDynamic>(vals[r]);
+  }
+
+  template <class T, size_t N>
+    requires(N == m_size_dynamic && N == 0)
+  constexpr maybe_static_array(const std::array<T, N>&) : m_dyn_vals{} {}
+
+  template <class T, size_t N>
+    requires(N == m_size_dynamic && N > 0)
+  constexpr maybe_static_array(const std::span<T, N>& vals) {
+    for (size_t r = 0; r < N; r++)
+      m_dyn_vals[r] = static_cast<TDynamic>(vals[r]);
+  }
+
+  template <class T, size_t N>
+    requires(N == m_size_dynamic && N == 0)
+  constexpr maybe_static_array(const std::span<T, N>&) : m_dyn_vals{} {}
+
+  // constructors from all values
+  template <class... DynVals>
+    requires(sizeof...(DynVals) != m_size_dynamic && m_size_dynamic > 0)
+  constexpr maybe_static_array(DynVals... vals) {
+    static_assert((sizeof...(DynVals) == m_size), "Invalid number of values.");
+    TDynamic values[m_size]{static_cast<TDynamic>(vals)...};
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = values[r];
+      }
+// Precondition check
+#  ifdef _MDSPAN_DEBUG
+      else {
+        assert(values[r] == static_cast<TDynamic>(static_val));
+      }
+#  endif
+    }
+  }
+
+  template <class T, size_t N>
+    requires(N != m_size_dynamic && m_size_dynamic > 0)
+  constexpr maybe_static_array(const std::array<T, N>& vals) {
+    static_assert((N == m_size), "Invalid number of values.");
+// Precondition check
+#  ifdef _MDSPAN_DEBUG
+    assert(N == m_size);
+#  endif
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
+      }
+// Precondition check
+#  ifdef _MDSPAN_DEBUG
+      else {
+        assert(static_cast<TDynamic>(vals[r]) == static_cast<TDynamic>(static_val));
+      }
+#  endif
+    }
+  }
+
+  template <class T, size_t N>
+    requires(N != m_size_dynamic && m_size_dynamic > 0)
+  constexpr maybe_static_array(const std::span<T, N>& vals) {
+    static_assert((N == m_size) || (m_size == dynamic_extent));
+#  ifdef _MDSPAN_DEBUG
+    assert(N == m_size);
+#  endif
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
+      }
+#  ifdef _MDSPAN_DEBUG
+      else {
+        assert(static_cast<TDynamic>(vals[r]) == static_cast<TDynamic>(static_val));
+      }
+#  endif
+    }
+  }
+
+  // access functions
+  constexpr static TStatic static_value(size_t r) noexcept { return static_vals_t::get(r); }
+
+  constexpr TDynamic value(size_t r) const {
+    TStatic static_val = static_vals_t::get(r);
+    return static_val == dyn_tag ? m_dyn_vals[dyn_map_t::get(r)] : static_cast<TDynamic>(static_val);
+  }
+  constexpr TDynamic operator[](size_t r) const { return value(r); }
+
+  // observers
+  constexpr static size_t size() { return m_size; }
+  constexpr static size_t size_dynamic() { return m_size_dynamic; }
+};
+
+} // namespace detail
+
+// ------------------------------------------------------------------
+// ------------ extents ---------------------------------------------
+// ------------------------------------------------------------------
+
+// Class to describe the extents of a multi dimensional array.
+// Used by mdspan, mdarray and layout mappings.
+// See ISO C++ standard [mdspan.extents]
+
+template <class IndexType, size_t... Extents>
+class extents {
+public:
+  // typedefs for integral types used
+  using index_type = IndexType;
+  using size_type  = make_unsigned_t<index_type>;
+  using rank_type  = size_t;
+
+  static_assert(std::is_integral<index_type>::value && !std::is_same<index_type, bool>::value,
+                "extents::index_type must be a signed or unsigned integer type");
+
+private:
+  constexpr static rank_type m_rank         = sizeof...(Extents);
+  constexpr static rank_type m_rank_dynamic = ((Extents == dynamic_extent) + ... + 0);
+
+  // internal storage type using maybe_static_array
+  using vals_t = detail::maybe_static_array<IndexType, size_t, dynamic_extent, Extents...>;
+  [[no_unique_address]] vals_t m_vals;
+
+public:
+  // [mdspan.extents.obs], observers of multidimensional index space
+  constexpr static rank_type rank() noexcept { return m_rank; }
+  constexpr static rank_type rank_dynamic() noexcept { return m_rank_dynamic; }
+
+  constexpr index_type extent(rank_type r) const noexcept { return m_vals.value(r); }
+  constexpr static size_t static_extent(rank_type r) noexcept { return vals_t::static_value(r); }
+
+  // [mdspan.extents.cons], constructors
+  constexpr extents() noexcept = default;
+
+  // Construction from just dynamic or all values.
+  // Precondition check is deferred to maybe_static_array constructor
+  template <class... OtherIndexTypes>
+    requires((is_convertible_v<OtherIndexTypes, index_type> && ...) &&
+             (is_nothrow_constructible_v<index_type, OtherIndexTypes> && ...) &&
+             (sizeof...(OtherIndexTypes) == m_rank || sizeof...(OtherIndexTypes) == m_rank_dynamic))
+  constexpr explicit extents(OtherIndexTypes... dynvals) noexcept : m_vals(static_cast<index_type>(dynvals)...) {}
+
+  template <class OtherIndexType, size_t N>
+    requires(is_convertible_v<OtherIndexType, index_type>&& is_nothrow_constructible_v<index_type, OtherIndexType> &&
+             (N == m_rank || N == m_rank_dynamic))
+  explicit(N != m_rank_dynamic) constexpr extents(const array<OtherIndexType, N>& exts) noexcept
+      : m_vals(std::move(exts)) {}
+
+  template <class OtherIndexType, size_t N>
+    requires(is_convertible_v<OtherIndexType, index_type>&& is_nothrow_constructible_v<index_type, OtherIndexType> &&
+             (N == m_rank || N == m_rank_dynamic))
+  explicit(N != m_rank_dynamic) constexpr extents(const span<OtherIndexType, N>& exts) noexcept
+      : m_vals(std::move(exts)) {}
+
+private:
+  // Function to construct extents storage from other extents.
+  // With C++ 17 the first two variants could be collapsed using if constexpr
+  // in which case you don't need all the requires clauses.
+  // in C++ 14 mode that doesn't work due to infinite recursion
+  template <size_t DynCount, size_t R, class OtherExtents, class... DynamicValues>
+    requires((R < m_rank) && (static_extent(R) == dynamic_extent))
+  vals_t __construct_vals_from_extents(
+      std::integral_constant<size_t, DynCount>,
+      std::integral_constant<size_t, R>,
+      const OtherExtents& exts,
+      DynamicValues... dynamic_values)
+  noexcept {
+    return __construct_vals_from_extents(
+        std::integral_constant<size_t, DynCount + 1>(),
+        std::integral_constant<size_t, R + 1>(),
+        exts,
+        dynamic_values...,
+        exts.extent(R));
+  }
+
+  template <size_t DynCount, size_t R, class OtherExtents, class... DynamicValues>
+    requires((R < m_rank) && (static_extent(R) != dynamic_extent))
+  vals_t __construct_vals_from_extents(
+      std::integral_constant<size_t, DynCount>,
+      std::integral_constant<size_t, R>,
+      const OtherExtents& exts,
+      DynamicValues... dynamic_values)
+  noexcept {
+    return __construct_vals_from_extents(
+        std::integral_constant<size_t, DynCount>(), std::integral_constant<size_t, R + 1>(), exts, dynamic_values...);
+  }
+
+  template <size_t DynCount, size_t R, class OtherExtents, class... DynamicValues>
+    requires((R == m_rank) && (DynCount == m_rank_dynamic))
+  vals_t __construct_vals_from_extents(
+      std::integral_constant<size_t, DynCount>,
+      std::integral_constant<size_t, R>,
+      const OtherExtents&,
+      DynamicValues... dynamic_values)
+  noexcept { return vals_t{static_cast<index_type>(dynamic_values)...}; }
+
+public:
+  // Converting constructor from other extents specializations
+  template <class OtherIndexType, size_t... OtherExtents>
+    requires((sizeof...(OtherExtents) == sizeof...(Extents)) &&
+             ((OtherExtents == dynamic_extent || Extents == dynamic_extent || OtherExtents == Extents) && ...))
+  explicit(
+      (((Extents != dynamic_extent) && (OtherExtents == dynamic_extent)) || ...) ||
+      (std::numeric_limits<index_type>::max() <
+       std::numeric_limits<OtherIndexType>::max())) constexpr extents(const extents<OtherIndexType, OtherExtents...>&
+                                                                          other) noexcept
+      : m_vals(__construct_vals_from_extents(
+            std::integral_constant<size_t, 0>(), std::integral_constant<size_t, 0>(), other)) {}
+
+  // Comparison operator
+  template <class OtherIndexType, size_t... OtherExtents>
+  friend constexpr bool operator==(const extents& lhs, const extents<OtherIndexType, OtherExtents...>& rhs) noexcept {
+    bool value = true;
+    if constexpr (rank() != sizeof...(OtherExtents)) {
+      value = false;
+    } else {
+      for (size_type r = 0; r < m_rank; r++)
+        value &= static_cast<index_type>(rhs.extent(r)) == lhs.extent(r);
+    }
+    return value;
+  }
+
+  template <class OtherIndexType, size_t... OtherExtents>
+  friend constexpr bool operator!=(extents const& lhs, extents<OtherIndexType, OtherExtents...> const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+};
+
+// Recursive helper classes to implement dextents alias for extents
+namespace detail {
+
+template <class IndexType, size_t Rank, class Extents = extents<IndexType>>
+struct __make_dextents;
+
+template <class IndexType, size_t Rank, size_t... ExtentsPack>
+struct __make_dextents< IndexType, Rank, extents<IndexType, ExtentsPack...>> {
+  using type = typename __make_dextents< IndexType, Rank - 1, extents<IndexType, dynamic_extent, ExtentsPack...>>::type;
+};
+
+template <class IndexType, size_t... ExtentsPack>
+struct __make_dextents< IndexType, 0, extents<IndexType, ExtentsPack...>> {
+  using type = extents<IndexType, ExtentsPack...>;
+};
+
+} // end namespace detail
+
+// [mdspan.extents.dextents], alias template
+template <class IndexType, size_t Rank>
+using dextents = typename 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 detail {
+
+template <class T>
+struct __is_extents : ::std::false_type {};
+
+template <class IndexType, size_t... ExtentsPack>
+struct __is_extents<extents<IndexType, ExtentsPack...>> : ::std::true_type {};
+
+template <class T>
+inline constexpr bool __is_extents_v = __is_extents<T>::value;
+
+} // namespace detail
+
+#endif // _LIBCPP_STD_VER > 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_EXTENTS

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
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_MDSPAN
+#define _LIBCPP_MDSPAN
+
+#include <__config>
+#include <__mdspan/extents.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_MDSPAN

libcxx/include/module.modulemap.in

module locale {
     header "locale"
     export *
   }
   module map {
     header "map"
     export initializer_list
     export *
   }
+  module mdspan {
+    header "mdspan"
+    export array
+    export span
+    export *
+
+    module __mdspan {
+      module extents                         { private header "__mdspan/extents.h" }
+    }
+  }
   module memory {
     header "memory"
     export *
 
     module __memory {
       module addressof                       { private header "__memory/addressof.h" }
       module align                           { private header "__memory/align.h" }
       module aligned_alloc                   { private header "__memory/aligned_alloc.h" }

libcxx/test/std/containers/views/mdspan/extents/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 CONVERTIBLE_TO_INTEGRAL_H
+#define 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; }
+};
+
+#endif

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

+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class To, class From>
+void test_comparison(bool equal, To dest, From src) {
+  assert((dest == src) == equal);
+  assert((dest != src) != equal);
+}
+
+template <class T1, class T2>
+void test_comparison_different_rank() {
+  constexpr size_t D = std::dynamic_extent;
+
+  test_comparison(false, std::extents<T1>(), std::extents<T2, D>(1));
+  test_comparison(false, std::extents<T1>(), std::extents<T2, 1>());
+
+  test_comparison(false, std::extents<T1, D>(1), std::extents<T2>());
+  test_comparison(false, std::extents<T1, 1>(), std::extents<T2>());
+
+  test_comparison(false, std::extents<T1, D>(5), std::extents<T2, D, D>(5, 5));
+  test_comparison(false, std::extents<T1, 5>(), std::extents<T2, 5, D>(5));
+  test_comparison(false, std::extents<T1, 5>(), std::extents<T2, 5, 1>());
+
+  test_comparison(false, std::extents<T1, D, D>(5, 5), std::extents<T2, D>(5));
+  test_comparison(false, std::extents<T1, 5, D>(5), std::extents<T2, D>(5));
+  test_comparison(false, std::extents<T1, 5, 5>(), std::extents<T2, 5>());
+}
+
+template <class T1, class T2>
+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>
+void test_comparison() {
+  test_comparison_same_rank<T1, T2>();
+  test_comparison_different_rank<T1, T2>();
+}
+
+int main() {
+  test_comparison<int, int>();
+  test_comparison<int, size_t>();
+  test_comparison<size_t, int>();
+  test_comparison<size_t, long>();
+}

libcxx/test/std/containers/views/mdspan/extents/cons.fail.cpp

+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "ConvertibleToIntegral.h"
+#include "test_macros.h"
+
+template <class E>
+void implicit_construction(E) {}
+
+template <class T>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+
+  // clang-format off
+  // test less than rank_dynammic args
+  {
+    std::array a1{3};
+    std::span<int, 1> s1(a1.data(), 1);
+    std::extents<T, 1, D, 3, D> e1(2); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e2(a1); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e3(s1); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    (void)e1;
+    (void)e2;
+    (void)e3;
+  }
+  // test more than rank_dynammic but less than rank args
+  {
+    std::array a3{3, 4, 5};
+    std::span<int, 3> s3(a3.data(), 3);
+    std::extents<T, 1, D, 3, D> e1(3, 4, 5); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e2(a3); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e3(s3); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    (void)e1;
+    (void)e2;
+    (void)e3;
+  }
+  // test more than rank args
+  {
+    std::array a5{3, 4, 5, 6, 7};
+    std::span<int, 5> s5(a5.data(), 5);
+    std::extents<T, 1, D, 3, D> e1(3, 4, 5, 6, 7); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e2(a5); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e3(s5); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    (void)e1;
+    (void)e2;
+    (void)e3;
+  }
+
+  // test implicit construction fails from span and array if all extents are given
+  {
+    std::array a5{3, 4, 5, 6, 7};
+    std::span<int, 5> s5(a5.data(), 5);
+    // check that explicit construction works, i.e. no error
+    std::extents<int, D, D, 5, D, D> e1(a5);
+    std::extents<int, D, D, 5, D, D> e2(s5);
+    (void)e1;
+    (void)e2;
+    implicit_construction<std::extents<int, D, D, 5, D, D>>(a5); // expected-error {{no matching function for call to 'implicit_construction'}}
+    implicit_construction<std::extents<int, D, D, 5, D, D>>(s5); // expected-error {{no matching function for call to 'implicit_construction'}}
+  }
+  // test construction fails from types not convertible to index_type but convertible to other integer types
+  {
+     std::array a{IntType(3)};
+     std::span<IntType, 1> s{a};
+     std::extents<unsigned long, D> e1(IntType(3)); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, D>'}}
+     std::extents<unsigned long, D> e2(a); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, D>'}}
+     std::extents<unsigned long, D> e3(s); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, D>'}}
+     (void)e1;
+     (void)e2;
+     (void)e3;
+  }
+  // clang-format on
+}
+
+int main() { test<unsigned long>(); }

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

+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "ConvertibleToIntegral.h"
+#include "test_macros.h"
+
+// 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
+
+template <class E, class AllExtents>
+void test_runtime_observers(E ext, AllExtents expected) {
+  for (typename E::rank_type r = 0; r < ext.rank(); r++) {
+    ASSERT_SAME_TYPE(decltype(ext.extent(0)), typename E::index_type);
+    assert(ext.extent(r) == static_cast<typename E::index_type>(expected[r]));
+  }
+}
+
+template <class E, class AllExtents>
+void test_implicit_construction_call(E e, AllExtents all_ext) {
+  test_runtime_observers(e, all_ext);
+}
+
+template <class E, class AllExtents, class Extents>
+void test_implicit_construction(AllExtents all_ext, Extents ext) {
+  test_implicit_construction_call<E>(ext, all_ext);
+  test_implicit_construction_call<E>(
+      std::span<typename Extents::value_type, E::rank_dynamic()>(ext.data(), ext.size()), all_ext);
+}
+
+template <class E, class AllExtents, class Extents, size_t... Indices>
+void test_construction(AllExtents all_ext, Extents ext, std::index_sequence<Indices...>) {
+  // construction from indices
+  test_runtime_observers(E(ext[Indices]...), all_ext);
+  // construction from array
+  test_runtime_observers(E(ext), all_ext);
+  // construction from span
+  test_runtime_observers(
+      E(std::span<typename Extents::value_type, sizeof...(Indices)>(ext.data(), sizeof...(Indices))), all_ext);
+}
+
+template <class E, class AllExtents>
+void test_construction(AllExtents all_ext) {
+  // test construction from all extents
+  test_construction<E>(all_ext, all_ext, std::make_index_sequence<E::rank()>());
+
+  // test construction from just dynamic extents
+  // create an array of just the extents corresponding to dynamic values
+  std::array<typename AllExtents::value_type, E::rank_dynamic()> dyn_ext;
+  size_t dynamic_idx = 0;
+  for (size_t r = 0; r < E::rank(); r++) {
+    if (E::static_extent(r) == std::dynamic_extent) {
+      dyn_ext[dynamic_idx] = all_ext[r];
+      dynamic_idx++;
+    }
+  }
+  test_construction<E>(all_ext, dyn_ext, std::make_index_sequence<E::rank_dynamic()>());
+  test_implicit_construction<E>(all_ext, dyn_ext);
+}
+
+template <class T, class TArg>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+
+  test_construction<std::extents<T>>(std::array<TArg, 0>{});
+
+  test_construction<std::extents<T, 3>>(std::array<TArg, 1>{3});
+  test_construction<std::extents<T, D>>(std::array<TArg, 1>{3});
+
+  test_construction<std::extents<T, 3, 7>>(std::array<TArg, 2>{3, 7});
+  test_construction<std::extents<T, 3, D>>(std::array<TArg, 2>{3, 7});
+  test_construction<std::extents<T, D, 7>>(std::array<TArg, 2>{3, 7});
+  test_construction<std::extents<T, D, D>>(std::array<TArg, 2>{3, 7});
+
+  test_construction<std::extents<T, 3, 7, 9>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, 3, 7, D>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, 3, D, D>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, D, 7, D>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, D, D, D>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, 3, D, 9>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, D, D, 9>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, D, 7, 9>>(std::array<TArg, 3>{3, 7, 9});
+
+  test_construction<std::extents<T, 1, 2, 3, 4, 5, 6, 7, 8, 9>>(std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
+  test_construction<std::extents<T, D, 2, 3, D, 5, D, 7, D, 9>>(std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
+  test_construction<std::extents<T, D, D, D, D, D, D, D, D, D>>(std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
+}
+
+int main() {
+  test<int, int>();
+  test<int, size_t>();
+  test<unsigned, int>();
+  test<char, size_t>();
+  test<long long, unsigned>();
+  test<size_t, int>();
+  test<size_t, size_t>();
+  test<int, IntType>();
+  test<unsigned char, IntType>();
+}

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

+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "ConvertibleToIntegral.h"
+#include "test_macros.h"
+
+// 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
+
+// All of this should work in constant expressions
+
+// This tests the actual observers and returns the sum of extents + rank
+template <class E, class AllExtents>
+constexpr size_t test_runtime_observers(E ext, AllExtents expected) {
+  size_t result = 0;
+  for (typename E::rank_type r = 0; r < ext.rank(); r++) {
+    result += ext.extent(r) == static_cast<typename E::index_type>(expected[r]);
+    result += ext.extent(r);
+  }
+  return result;
+}
+
+// Make sure constexpr usage of extents works in implicit construction
+template <class E, class AllExtents>
+constexpr size_t test_implicit_construction_call(E e, AllExtents all_ext) {
+  return test_runtime_observers(e, all_ext);
+}
+
+template <class E, class AllExtents, class Extents>
+constexpr size_t test_implicit_construction(AllExtents all_ext, Extents ext) {
+  return test_implicit_construction_call<E>(ext, all_ext) +
+         test_implicit_construction_call<E>(
+             std::span<typename Extents::value_type, E::rank_dynamic()>(ext.data(), ext.size()), all_ext);
+}
+
+template <class E, class AllExtents, class Extents, size_t... Indices>
+constexpr size_t test_construction(AllExtents all_ext, Extents ext, std::index_sequence<Indices...>) {
+  size_t result = 0;
+  // construction from indicies
+  result += test_runtime_observers(E(ext[Indices]...), all_ext);
+  // construction from array
+  result += test_runtime_observers(E(ext), all_ext);
+  // construction from span
+  result += test_runtime_observers(
+      E(std::span<typename Extents::value_type, sizeof...(Indices)>(ext.data(), sizeof...(Indices))), all_ext);
+  return result;
+}
+
+template <class E, class AllExtents>
+constexpr size_t test_construction(AllExtents all_ext) {
+  size_t result = 0;
+  // test construction from all extents
+  result += test_construction<E>(all_ext, all_ext, std::make_index_sequence<E::rank()>());
+
+  // test construction from just dynamic extents
+  // create an array of just the extents corresponding to dynamic values
+  std::array<typename AllExtents::value_type, E::rank_dynamic()> dyn_ext{0};
+  size_t dynamic_idx = 0;
+  for (size_t r = 0; r < E::rank(); r++) {
+    if (E::static_extent(r) == std::dynamic_extent) {
+      dyn_ext[dynamic_idx] = all_ext[r];
+      dynamic_idx++;
+    }
+  }
+  result += test_construction<E>(all_ext, dyn_ext, std::make_index_sequence<E::rank_dynamic()>());
+  result += test_implicit_construction<E>(all_ext, dyn_ext);
+  return result;
+}
+
+template <size_t result, size_t expected>
+struct const_expr {
+  // num_tests is how many different construction scenarios each
+  // construction tests expands to in the end.
+  // expected is the value each individual test return
+  constexpr static size_t num_tests = 8;
+  constexpr static bool value       = result == num_tests * expected;
+};
+
+template <class T, class TArg>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+
+  static_assert(const_expr<test_construction<std::extents<T>>(std::array<TArg, 0>{}), 0>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, 3>>(std::array<TArg, 1>{3}), 3 + 1>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, D>>(std::array<TArg, 1>{3}), 3 + 1>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, 3, 7>>(std::array<TArg, 2>{3, 7}), 10 + 2>::value);
+  static_assert(const_expr<test_construction<std::extents<T, 3, D>>(std::array<TArg, 2>{3, 7}), 10 + 2>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, 7>>(std::array<TArg, 2>{3, 7}), 10 + 2>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, D>>(std::array<TArg, 2>{3, 7}), 10 + 2>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, 3, 7, 9>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, 3, 7, D>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, 3, D, D>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, 7, D>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, D, D>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, 3, D, 9>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, D, 9>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, 7, 9>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, 1, 2, 3, 4, 5, 6, 7, 8, 9>>(
+                               std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+                           45 + 9>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, 2, 3, D, 5, D, 7, D, 9>>(
+                               std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+                           45 + 9>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, D, D, D, D, D, D, D, D>>(
+                               std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+                           45 + 9>::value);
+}
+
+int main() {
+  test<int, int>();
+  test<int, size_t>();
+  test<char, size_t>();
+  test<int, IntType>();
+  test<unsigned char, IntType>();
+}

libcxx/test/std/containers/views/mdspan/extents/conversion.fail.cpp

+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+// std::extents can be converted into each other as long as there aren't any
+// mismatched static extents.
+// Convertibility requires that no runtime dimension is assigned to a static dimension,
+// and that the destinations index_type has a larger or equal max value than the
+// sources index_type
+
+// clang-format off
+void test_no_implicit_conversion() {
+  constexpr size_t D = std::dynamic_extent;
+  {
+    std::extents<int, D> from;
+    std::extents<int, 5> to;
+    to = from; // expected-error {{no viable overloaded '='}}
+  }
+  {
+    std::extents<int, D, 7> from;
+    std::extents<int, 5, 7> to;
+    to = from; // expected-error {{no viable overloaded '='}}
+  }
+  {
+    std::extents<size_t, D> from;
+    std::extents<int, D> to;
+    to = from; // expected-error {{no viable overloaded '='}}
+  }
+  {
+    std::extents<size_t, 5> from;
+    std::extents<int, 5> to;
+    to = from; // expected-error {{no viable overloaded '='}}
+  }
+}
+
+void test_rank_mismatch() {
+  constexpr size_t D = std::dynamic_extent;
+  {
+    std::extents<int> from;
+    std::extents<int, D> to(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, D>'}}
+    (void) to;
+  }
+  {
+    std::extents<int, D, D> from;
+    std::extents<int> to0(from); // expected-error {{no matching constructor for initialization of 'std::extents<int>'}}
+    std::extents<int, D> to1(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, D>'}}
+    std::extents<int, D, D, D> to3(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, D, D, D>'}}
+    (void) to0;
+    (void) to1;
+    (void) to3;
+  }
+}
+
+void test_static_extent_mismatch() {
+  constexpr size_t D = std::dynamic_extent;
+  {
+    std::extents<int, 3> from;
+    std::extents<int, 2> to(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, 2>'}}
+    (void) to;
+  }
+  {
+    std::extents<int, 3, D> from;
+    std::extents<int, 2, D> to(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, 2, D>'}}
+    (void) to;
+  }
+  {
+    std::extents<int, D, 2> from;
+    std::extents<int, D, 3> to(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, D, 3>'}}
+    (void) to;
+  }
+}
+// clang-format on
+
+int main() {
+  test_rank_mismatch();
+  test_static_extent_mismatch();
+  test_no_implicit_conversion();
+}

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

+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+// std::extents can be converted into each other as long as there aren't any
+// mismatched static extents.
+// Convertibility requires that no runtime dimension is assigned to a static dimension,
+// and that the destinations index_type has a larger or equal max value than the
+// sources index_type
+
+template <class To, class From>
+void test_implicit_conversion(To dest, From src) {
+  assert(dest == src);
+}
+
+template <bool implicit, class To, class From>
+void test_conversion(From 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>
+void test_conversion() {
+  constexpr size_t D             = std::dynamic_extent;
+  constexpr bool idx_convertible = std::numeric_limits<T1>::max() >= 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
+}
+
+int main() {
+  test_conversion<int, int>();
+  test_conversion<int, size_t>();
+  test_conversion<size_t, int>();
+  test_conversion<size_t, long>();
+}

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

+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class E, size_t rank, size_t rank_dynamic, size_t... StaticExts, size_t... Indices>
+void test_static_observers(std::index_sequence<StaticExts...>, std::index_sequence<Indices...>) {
+  ASSERT_NOEXCEPT(E::rank());
+  static_assert(E::rank() == rank);
+  ASSERT_NOEXCEPT(E::rank_dynamic());
+  static_assert(E::rank_dynamic() == rank_dynamic);
+
+  // Let's only test this if the call isn't a precondition violation
+  if constexpr (rank > 0) {
+    ASSERT_NOEXCEPT(E::static_extent(0));
+    ASSERT_SAME_TYPE(decltype(E::static_extent(0)), size_t);
+    static_assert(((E::static_extent(Indices) == StaticExts) && ...));
+  }
+}
+
+template <class E, size_t rank, size_t rank_dynamic, size_t... StaticExts>
+void test_static_observers() {
+  test_static_observers<E, rank, rank_dynamic>(
+      std::index_sequence<StaticExts...>(), std::make_index_sequence<sizeof...(StaticExts)>());
+}
+
+template <class T>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+  constexpr size_t S = 5;
+
+  test_static_observers<std::extents<T>, 0, 0>();
+
+  test_static_observers<std::extents<T, S>, 1, 0, S>();
+  test_static_observers<std::extents<T, D>, 1, 1, D>();
+
+  test_static_observers<std::extents<T, S, S>, 2, 0, S, S>();
+  test_static_observers<std::extents<T, S, D>, 2, 1, S, D>();
+  test_static_observers<std::extents<T, D, S>, 2, 1, D, S>();
+  test_static_observers<std::extents<T, D, D>, 2, 2, D, D>();
+
+  test_static_observers<std::extents<T, S, S, S>, 3, 0, S, S, S>();
+  test_static_observers<std::extents<T, S, S, D>, 3, 1, S, S, D>();
+  test_static_observers<std::extents<T, S, D, S>, 3, 1, S, D, S>();
+  test_static_observers<std::extents<T, D, S, S>, 3, 1, D, S, S>();
+  test_static_observers<std::extents<T, S, D, D>, 3, 2, S, D, D>();
+  test_static_observers<std::extents<T, D, S, D>, 3, 2, D, S, D>();
+  test_static_observers<std::extents<T, D, D, S>, 3, 2, D, D, S>();
+  test_static_observers<std::extents<T, D, D, D>, 3, 3, D, D, D>();
+}
+
+int main() {
+  test<int>();
+  test<unsigned>();
+  test<char>();
+  test<long long>();
+  test<size_t>();
+}

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

+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class E, class IndexType, size_t... Extents>
+void testExtents() {
+  ASSERT_SAME_TYPE(typename E::index_type, IndexType);
+  ASSERT_SAME_TYPE(typename E::size_type, std::make_unsigned_t<IndexType>);
+  ASSERT_SAME_TYPE(typename E::rank_type, size_t);
+
+  static_assert(sizeof...(Extents) == E::rank());
+  static_assert((static_cast<size_t>(Extents == std::dynamic_extent) + ...) == E::rank_dynamic());
+
+  static_assert(std::regular<E>);
+  static_assert(std::is_trivially_copyable_v<E>);
+}
+
+template <class IndexType, size_t... Extents>
+void testExtents() {
+  testExtents<std::extents<IndexType, Extents...>, IndexType, Extents...>();
+}
+
+template <class T>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+  testExtents<T, D>();
+  testExtents<T, 3>();
+  testExtents<T, 3, 3>();
+  testExtents<T, 3, D>();
+  testExtents<T, D, 3>();
+  testExtents<T, D, D>();
+  testExtents<T, 3, 3, 3>();
+  testExtents<T, 3, 3, D>();
+  testExtents<T, 3, D, D>();
+  testExtents<T, D, 3, D>();
+  testExtents<T, D, D, D>();
+  testExtents<T, 3, D, 3>();
+  testExtents<T, D, 3, 3>();
+  testExtents<T, D, D, 3>();
+
+  testExtents<T, 9, 8, 7, 6, 5, 4, 3, 2, 1>();
+  testExtents<T, 9, D, 7, 6, D, D, 3, D, D>();
+  testExtents<T, D, D, D, D, D, D, D, D, D>();
+}
+
+int main() {
+  test<int>();
+  test<unsigned>();
+  test<char>();
+  test<long long>();
+  test<size_t>();
+}