[libc++] Disallow character types being index types of extents (llvm#105832)

frederick-vs-ja · web-flow · commit 74e70bae15b2 · 2024-08-27T16:41:55.000-04:00
llvm#78086 provided the trait we want to use for this: `__libcpp_integer`. In some `libcxx/containers/views/mdspan` tests, improper uses of `char` are replaced with `signed char`. Fixes llvm#73715
diff --git a/libcxx/include/__mdspan/extents.h b/libcxx/include/__mdspan/extents.h
@@ -19,6 +19,8 @@
 
 #include <__assert>
 #include <__config>
+
+#include <__concepts/arithmetic.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_nothrow_constructible.h>
@@ -282,8 +284,7 @@ class extents {
   using size_type  = make_unsigned_t<index_type>;
   using rank_type  = size_t;
 
-  static_assert(is_integral<index_type>::value && !is_same<index_type, bool>::value,
-                "extents::index_type must be a signed or unsigned integer type");
+  static_assert(__libcpp_integer<index_type>, "extents::index_type must be a signed or unsigned integer type");
   static_assert(((__mdspan_detail::__is_representable_as<index_type>(_Extents) || (_Extents == dynamic_extent)) && ...),
                 "extents ctor: arguments must be representable as index_type and nonnegative");
 
diff --git a/libcxx/test/libcxx/containers/views/mdspan/extents/assert.conversion.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/extents/assert.conversion.pass.cpp
@@ -50,7 +50,7 @@ int main(int, char**) {
   }
   // value out of range
   {
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<char, D, 5> e(arg); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<signed char, D, 5> e(arg); }()),
                                "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   return 0;
diff --git a/libcxx/test/libcxx/containers/views/mdspan/extents/assert.ctor_from_array.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/extents/assert.ctor_from_array.pass.cpp
@@ -51,19 +51,13 @@ int main(int, char**) {
   }
   // value out of range
   {
-    TEST_LIBCPP_ASSERT_FAILURE(
-        ([] {
-          std::extents<char, D, 5> e1(std::array{1000, 5});
-        }()),
-        "extents ctor: arguments must be representable as index_type and nonnegative");
+    TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<signed char, D, 5> e1(std::array{1000, 5}); }()),
+                               "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   // negative value
   {
-    TEST_LIBCPP_ASSERT_FAILURE(
-        ([] {
-          std::extents<char, D, 5> e1(std::array{-1, 5});
-        }()),
-        "extents ctor: arguments must be representable as index_type and nonnegative");
+    TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<signed char, D, 5> e1(std::array{-1, 5}); }()),
+                               "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   return 0;
 }
diff --git a/libcxx/test/libcxx/containers/views/mdspan/extents/assert.ctor_from_integral.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/extents/assert.ctor_from_integral.pass.cpp
@@ -50,12 +50,12 @@ int main(int, char**) {
   }
   // value out of range
   {
-    TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<char, D, 5> e1(1000, 5); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<signed char, D, 5> e1(1000, 5); }()),
                                "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   // negative value
   {
-    TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<char, D, 5> e1(-1, 5); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<signed char, D, 5> e1(-1, 5); }()),
                                "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   return 0;
diff --git a/libcxx/test/libcxx/containers/views/mdspan/extents/assert.ctor_from_span.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/extents/assert.ctor_from_span.pass.cpp
@@ -49,13 +49,13 @@ int main(int, char**) {
   // value out of range
   {
     std::array args{1000, 5};
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<char, D, 5> e1(std::span{args}); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<signed char, D, 5> e1(std::span{args}); }()),
                                "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   // negative value
   {
     std::array args{-1, 5};
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<char, D, 5> e1(std::span{args}); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<signed char, D, 5> e1(std::span{args}); }()),
                                "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   return 0;
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_left/assert.conversion.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_left/assert.conversion.pass.cpp
@@ -42,17 +42,20 @@ int main(int, char**) {
   }
   // non-representability of extents itself
   {
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_left::mapping<std::extents<char, D>> m(
-                                 std::layout_left::mapping<std::extents<int, D>>(std::extents<int, D>(500))); }()),
-                               "extents ctor: arguments must be representable as index_type and nonnegative");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        ([=] {
+          std::layout_left::mapping<std::extents<signed char, D>> m(
+              std::layout_left::mapping<std::extents<int, D>>(std::extents<int, D>(500)));
+        }()),
+        "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   // required_span_size not representable, while individual extents are
   {
     // check extents would be constructible
-    [[maybe_unused]] std::extents<char, D, 5> e(arg_exts);
+    [[maybe_unused]] std::extents<signed char, D, 5> e(arg_exts);
     // but the product is not, so we can't use it for layout_left
     TEST_LIBCPP_ASSERT_FAILURE(
-        ([=] { std::layout_left::mapping<std::extents<char, D, 5>> m(arg); }()),
+        ([=] { std::layout_left::mapping<std::extents<signed char, D, 5>> m(arg); }()),
         "layout_left::mapping converting ctor: other.required_span_size() must be representable as index_type.");
   }
   return 0;
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_left/assert.ctor.extents.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_left/assert.ctor.extents.pass.cpp
@@ -13,7 +13,6 @@
 
 // <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]).
@@ -32,7 +31,7 @@ int main(int, char**) {
   {
     // the extents are representable but the product is not, so we can't use it for layout_left
     TEST_LIBCPP_ASSERT_FAILURE(
-        ([=] { std::layout_left::mapping<std::extents<char, D, 5>> m(std::extents<char, D, 5>(100)); }()),
+        ([=] { std::layout_left::mapping<std::extents<signed char, D, 5>> m(std::extents<signed char, D, 5>(100)); }()),
         "layout_left::mapping extents ctor: product of extents must be representable as index_type.");
   }
   return 0;
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_left/assert.ctor.layout_right.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_left/assert.ctor.layout_right.pass.cpp
@@ -44,9 +44,12 @@ int main(int, char**) {
   }
   // non-representability of extents itself
   {
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_left::mapping<std::extents<char, D>> m(
-                                 std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(500))); }()),
-                               "extents ctor: arguments must be representable as index_type and nonnegative");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        ([=] {
+          std::layout_left::mapping<std::extents<signed char, D>> m(
+              std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(500)));
+        }()),
+        "extents ctor: arguments must be representable as index_type and nonnegative");
   }
 
   // Can't trigger required_span_size() representability assertion, since for rank-1 the above check will trigger first,
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_left/assert.ctor.layout_stride.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_left/assert.ctor.layout_stride.pass.cpp
@@ -54,14 +54,14 @@ int main(int, char**) {
   // non-representability of extents itself
   {
     std::layout_stride::mapping arg(std::extents<int, D>(500), std::array<int, 1>{1});
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_left::mapping<std::extents<char, D>> m(arg); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_left::mapping<std::extents<signed char, D>> m(arg); }()),
                                "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   // non-representability of required span size
   {
     std::layout_stride::mapping arg(std::extents<int, D, D>(100, 3), std::array<int, 2>{1, 100});
     TEST_LIBCPP_ASSERT_FAILURE(
-        ([=] { std::layout_left::mapping<std::extents<char, D, D>> m(arg); }()),
+        ([=] { std::layout_left::mapping<std::extents<signed char, D, D>> m(arg); }()),
         "layout_left::mapping from layout_stride ctor: other.required_span_size() must be "
         "representable as index_type.");
   }
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_right/assert.conversion.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_right/assert.conversion.pass.cpp
@@ -42,17 +42,20 @@ int main(int, char**) {
   }
   // non-representability of extents itself
   {
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_right::mapping<std::extents<char, D>> m(
-                                 std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(500))); }()),
-                               "extents ctor: arguments must be representable as index_type and nonnegative");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        ([=] {
+          std::layout_right::mapping<std::extents<signed char, D>> m(
+              std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(500)));
+        }()),
+        "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   // required_span_size not representable, while individual extents are
   {
     // check extents would be constructible
-    [[maybe_unused]] std::extents<char, D, 5> e(arg_exts);
+    [[maybe_unused]] std::extents<signed 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::mapping<std::extents<char, D, 5>> m(arg); }()),
+        ([=] { std::layout_right::mapping<std::extents<signed char, D, 5>> m(arg); }()),
         "layout_right::mapping converting ctor: other.required_span_size() must be representable as index_type.");
   }
   return 0;
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_right/assert.ctor.extents.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_right/assert.ctor.extents.pass.cpp
@@ -31,7 +31,9 @@ int main(int, char**) {
   {
     // 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::mapping<std::extents<char, D, 5>> m(std::extents<char, D, 5>(100)); }()),
+        ([=] {
+          std::layout_right::mapping<std::extents<signed char, D, 5>> m(std::extents<signed char, D, 5>(100));
+        }()),
         "layout_right::mapping extents ctor: product of extents must be representable as index_type.");
   }
   return 0;
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_right/assert.ctor.layout_left.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_right/assert.ctor.layout_left.pass.cpp
@@ -44,9 +44,12 @@ int main(int, char**) {
   }
   // non-representability of extents itself
   {
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_right::mapping<std::extents<char, D>> m(
-                                 std::layout_left::mapping<std::extents<int, D>>(std::extents<int, D>(500))); }()),
-                               "extents ctor: arguments must be representable as index_type and nonnegative");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        ([=] {
+          std::layout_right::mapping<std::extents<signed char, D>> m(
+              std::layout_left::mapping<std::extents<int, D>>(std::extents<int, D>(500)));
+        }()),
+        "extents ctor: arguments must be representable as index_type and nonnegative");
   }
 
   // Can't trigger required_span_size() representability assertion, since for rank-1 the above check will trigger first,
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_right/assert.ctor.layout_stride.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_right/assert.ctor.layout_stride.pass.cpp
@@ -54,14 +54,14 @@ int main(int, char**) {
   // non-representability of extents itself
   {
     std::layout_stride::mapping arg(std::extents<int, D>(500), std::array<int, 1>{1});
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_right::mapping<std::extents<char, D>> m(arg); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_right::mapping<std::extents<signed char, D>> m(arg); }()),
                                "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   // non-representability of required span size
   {
     std::layout_stride::mapping arg(std::extents<int, D, D>(100, 3), std::array<int, 2>{3, 1});
     TEST_LIBCPP_ASSERT_FAILURE(
-        ([=] { std::layout_right::mapping<std::extents<char, D, D>> m(arg); }()),
+        ([=] { std::layout_right::mapping<std::extents<signed char, D, D>> m(arg); }()),
         "layout_right::mapping from layout_stride ctor: other.required_span_size() must be "
         "representable as index_type.");
   }
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_stride/assert.conversion.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_stride/assert.conversion.pass.cpp
@@ -65,26 +65,26 @@ int main(int, char**) {
   {
     TEST_LIBCPP_ASSERT_FAILURE(
         ([=] {
-          std::layout_stride::mapping<std::extents<char, D>> m(
+          std::layout_stride::mapping<std::extents<signed char, D>> m(
               std::layout_stride::mapping<std::extents<int, D>>(std::extents<int, D>(500), std::array<int, 1>{1}));
         }()),
         "extents ctor: arguments must be representable as index_type and nonnegative");
   }
   // all strides must be larger than zero
   {
     always_convertible_layout::mapping<std::dextents<int, 2>> offset_map(std::dextents<int, 2>{10, 10}, 100, -1);
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_stride::mapping<std::extents<char, D, D>> m(offset_map); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_stride::mapping<std::extents<signed char, D, D>> m(offset_map); }()),
                                "layout_stride::mapping converting ctor: all strides must be greater than 0");
   }
   // required_span_size not representable, while individual extents are
   {
     std::extents<int, D, D> arg_exts{100, 5};
     std::layout_stride::mapping<std::extents<int, D, D>> arg(arg_exts, std::array<int, 2>{1, 100});
     // check extents would be constructible
-    [[maybe_unused]] std::extents<char, D, 5> e(arg_exts);
+    [[maybe_unused]] std::extents<signed char, D, 5> e(arg_exts);
     // but the product is not, so we can't use it for layout_stride
     TEST_LIBCPP_ASSERT_FAILURE(
-        ([=] { std::layout_stride::mapping<std::extents<char, D, 5>> m(arg); }()),
+        ([=] { std::layout_stride::mapping<std::extents<signed char, D, 5>> m(arg); }()),
         "layout_stride::mapping converting ctor: other.required_span_size() must be representable as index_type.");
   }
   // required_span_size not representable, while individual extents are, edge case
@@ -104,7 +104,7 @@ int main(int, char**) {
   // base offset must be 0 (i.e. mapping(0,...,0)==0) for a strided layout with positive strides
   {
     always_convertible_layout::mapping<std::dextents<int, 2>> offset_map(std::dextents<int, 2>{10, 10}, 3);
-    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_stride::mapping<std::extents<char, D, D>> m(offset_map); }()),
+    TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_stride::mapping<std::extents<signed char, D, D>> m(offset_map); }()),
                                "layout_stride::mapping converting ctor: base offset of mapping must be zero.");
   }
   return 0;
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_stride/assert.ctor.extents_array.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_stride/assert.ctor.extents_array.pass.cpp
@@ -41,8 +41,8 @@ int main(int, char**) {
   // the extents are representable but the product with strides is not, so we can't use it for layout_stride
   TEST_LIBCPP_ASSERT_FAILURE(
       ([=] {
-        std::layout_stride::mapping<std::extents<char, D, 5>> m(
-            std::extents<char, D, 5>(20), std::array<int, 2>{20, 1});
+        std::layout_stride::mapping<std::extents<signed char, D, 5>> m(
+            std::extents<signed char, D, 5>(20), std::array<int, 2>{20, 1});
       }()),
       "layout_stride::mapping ctor: required span size is not representable as index_type.");
 
diff --git a/libcxx/test/libcxx/containers/views/mdspan/layout_stride/assert.ctor.extents_span.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/layout_stride/assert.ctor.extents_span.pass.cpp
@@ -44,7 +44,8 @@ int main(int, char**) {
     TEST_LIBCPP_ASSERT_FAILURE(
         ([=] {
           std::array<int, 2> strides{20, 1};
-          std::layout_stride::mapping<std::extents<char, D, 5>> m(std::extents<char, D, 5>(20), std::span(strides));
+          std::layout_stride::mapping<std::extents<signed char, D, 5>> m(
+              std::extents<signed char, D, 5>(20), std::span(strides));
         }()),
         "layout_stride::mapping ctor: required span size is not representable as index_type.");
 
diff --git a/libcxx/test/libcxx/containers/views/mdspan/mdspan/assert.size.pass.cpp b/libcxx/test/libcxx/containers/views/mdspan/mdspan/assert.size.pass.cpp
@@ -29,18 +29,18 @@ int main(int, char**) {
   std::array<float, 10> data;
   // make sure we are not failing because of using index_type instead of size_type
   {
-    layout_wrapping_integral<4>::mapping<std::dextents<char, 2>> map(
-        std::dextents<char, 2>(100, 2), not_extents_constructible_tag());
-    std::mdspan<float, std::dextents<char, 2>, layout_wrapping_integral<4>> mds(data.data(), map);
-    assert(map.required_span_size() == char(8));
+    layout_wrapping_integral<4>::mapping<std::dextents<signed char, 2>> map(
+        std::dextents<signed char, 2>(100, 2), not_extents_constructible_tag());
+    std::mdspan<float, std::dextents<signed char, 2>, layout_wrapping_integral<4>> mds(data.data(), map);
+    assert(map.required_span_size() == static_cast<signed char>(8));
     assert((static_cast<unsigned char>(200) == mds.size()));
   }
   {
-    layout_wrapping_integral<4>::mapping<std::dextents<char, 2>> map(
-        std::dextents<char, 2>(100, 3), not_extents_constructible_tag());
-    std::mdspan<float, std::dextents<char, 2>, layout_wrapping_integral<4>> mds(data.data(), map);
+    layout_wrapping_integral<4>::mapping<std::dextents<signed char, 2>> map(
+        std::dextents<signed char, 2>(100, 3), not_extents_constructible_tag());
+    std::mdspan<float, std::dextents<signed char, 2>, layout_wrapping_integral<4>> mds(data.data(), map);
     // sanity check
-    assert(map.required_span_size() == char(12));
+    assert(map.required_span_size() == static_cast<signed char>(12));
     // 100 x 3 exceeds 256
     {
       TEST_LIBCPP_ASSERT_FAILURE(([=] { mds.size(); }()), "mdspan: size() is not representable as size_type");
diff --git a/libcxx/test/std/containers/views/mdspan/extents/index_type.verify.cpp b/libcxx/test/std/containers/views/mdspan/extents/index_type.verify.cpp
@@ -0,0 +1,49 @@
+//
+// 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 IndexType, size_t... Extents>
+//  class extents;
+//
+// Mandates:
+//   - IndexType is a signed or unsigned integer type, and
+//   - each element of Extents is either equal to dynamic_extent, or is representable as a value of type IndexType.
+
+#include <cstddef>
+#include <climits>
+#include <mdspan>
+
+void invalid_index_types() {
+  // expected-error@*:* {{static assertion failed: extents::index_type must be a signed or unsigned integer type}}
+  [[maybe_unused]] std::extents<char, '*'> ec;
+#ifndef TEST_HAS_NO_CHAR8_T
+  // expected-error@*:* {{static assertion failed: extents::index_type must be a signed or unsigned integer type}}
+  [[maybe_unused]] std::extents<char8_t, u8'*'> ec8;
+#endif
+  // expected-error@*:* {{static assertion failed: extents::index_type must be a signed or unsigned integer type}}
+  [[maybe_unused]] std::extents<char16_t, u'*'> ec16;
+  // expected-error@*:* {{static assertion failed: extents::index_type must be a signed or unsigned integer type}}
+  [[maybe_unused]] std::extents<char32_t, U'*'> ec32;
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  // expected-error@*:* {{static assertion failed: extents::index_type must be a signed or unsigned integer type}}
+  [[maybe_unused]] std::extents<wchar_t, L'*'> ewc;
+#endif
+}
+
+void invalid_extent_values() {
+  // expected-error-re@*:* {{static assertion failed {{.*}}extents ctor: arguments must be representable as index_type and nonnegative}}
+  [[maybe_unused]] std::extents<signed char, static_cast<std::size_t>(SCHAR_MAX) + 1> esc1;
+  // expected-error-re@*:* {{static assertion failed {{.*}}extents ctor: arguments must be representable as index_type and nonnegative}}
+  [[maybe_unused]] std::extents<signed char, std::dynamic_extent - 1> esc2;
+  // expected-error-re@*:* {{static assertion failed {{.*}}extents ctor: arguments must be representable as index_type and nonnegative}}
+  [[maybe_unused]] std::extents<unsigned char, static_cast<std::size_t>(UCHAR_MAX) + 1> euc1;
+  // expected-error-re@*:* {{static assertion failed {{.*}}extents ctor: arguments must be representable as index_type and nonnegative}}
+  [[maybe_unused]] std::extents<unsigned char, std::dynamic_extent - 1> euc2;
+}

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ int main(int, char**) {`
`50`	`50`	`}`
`51`	`51`	`// value out of range`
`52`	`52`	`{`
`53`		`- TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<char, D, 5> e(arg); }()),`
	`53`	`+ TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<signed char, D, 5> e(arg); }()),`
`54`	`54`	`"extents ctor: arguments must be representable as index_type and nonnegative");`
`55`	`55`	`}`
`56`	`56`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -51,19 +51,13 @@ int main(int, char**) {`
`51`	`51`	`}`
`52`	`52`	`// value out of range`
`53`	`53`	`{`
`54`		`- TEST_LIBCPP_ASSERT_FAILURE(`
`55`		`- ([] {`
`56`		`- std::extents<char, D, 5> e1(std::array{1000, 5});`
`57`		`- }()),`
`58`		`- "extents ctor: arguments must be representable as index_type and nonnegative");`
	`54`	`+ TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<signed char, D, 5> e1(std::array{1000, 5}); }()),`
	`55`	`+ "extents ctor: arguments must be representable as index_type and nonnegative");`
`59`	`56`	`}`
`60`	`57`	`// negative value`
`61`	`58`	`{`
`62`		`- TEST_LIBCPP_ASSERT_FAILURE(`
`63`		`- ([] {`
`64`		`- std::extents<char, D, 5> e1(std::array{-1, 5});`
`65`		`- }()),`
`66`		`- "extents ctor: arguments must be representable as index_type and nonnegative");`
	`59`	`+ TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<signed char, D, 5> e1(std::array{-1, 5}); }()),`
	`60`	`+ "extents ctor: arguments must be representable as index_type and nonnegative");`
`67`	`61`	`}`
`68`	`62`	`return 0;`
`69`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,12 +50,12 @@ int main(int, char**) {`
`50`	`50`	`}`
`51`	`51`	`// value out of range`
`52`	`52`	`{`
`53`		`- TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<char, D, 5> e1(1000, 5); }()),`
	`53`	`+ TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<signed char, D, 5> e1(1000, 5); }()),`
`54`	`54`	`"extents ctor: arguments must be representable as index_type and nonnegative");`
`55`	`55`	`}`
`56`	`56`	`// negative value`
`57`	`57`	`{`
`58`		`- TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<char, D, 5> e1(-1, 5); }()),`
	`58`	`+ TEST_LIBCPP_ASSERT_FAILURE(([] { std::extents<signed char, D, 5> e1(-1, 5); }()),`
`59`	`59`	`"extents ctor: arguments must be representable as index_type and nonnegative");`
`60`	`60`	`}`
`61`	`61`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -49,13 +49,13 @@ int main(int, char**) {`
`49`	`49`	`// value out of range`
`50`	`50`	`{`
`51`	`51`	`std::array args{1000, 5};`
`52`		`- TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<char, D, 5> e1(std::span{args}); }()),`
	`52`	`+ TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<signed char, D, 5> e1(std::span{args}); }()),`
`53`	`53`	`"extents ctor: arguments must be representable as index_type and nonnegative");`
`54`	`54`	`}`
`55`	`55`	`// negative value`
`56`	`56`	`{`
`57`	`57`	`std::array args{-1, 5};`
`58`		`- TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<char, D, 5> e1(std::span{args}); }()),`
	`58`	`+ TEST_LIBCPP_ASSERT_FAILURE(([=] { std::extents<signed char, D, 5> e1(std::span{args}); }()),`
`59`	`59`	`"extents ctor: arguments must be representable as index_type and nonnegative");`
`60`	`60`	`}`
`61`	`61`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -42,17 +42,20 @@ int main(int, char**) {`
`42`	`42`	`}`
`43`	`43`	`// non-representability of extents itself`
`44`	`44`	`{`
`45`		`- TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_left::mapping<std::extents<char, D>> m(`
`46`		`- std::layout_left::mapping<std::extents<int, D>>(std::extents<int, D>(500))); }()),`
`47`		`- "extents ctor: arguments must be representable as index_type and nonnegative");`
	`45`	`+ TEST_LIBCPP_ASSERT_FAILURE(`
	`46`	`+ ([=] {`
	`47`	`+ std::layout_left::mapping<std::extents<signed char, D>> m(`
	`48`	`+ std::layout_left::mapping<std::extents<int, D>>(std::extents<int, D>(500)));`
	`49`	`+ }()),`
	`50`	`+ "extents ctor: arguments must be representable as index_type and nonnegative");`
`48`	`51`	`}`
`49`	`52`	`// required_span_size not representable, while individual extents are`
`50`	`53`	`{`
`51`	`54`	`// check extents would be constructible`
`52`		`- [[maybe_unused]] std::extents<char, D, 5> e(arg_exts);`
	`55`	`+ [[maybe_unused]] std::extents<signed char, D, 5> e(arg_exts);`
`53`	`56`	`// but the product is not, so we can't use it for layout_left`
`54`	`57`	`TEST_LIBCPP_ASSERT_FAILURE(`
`55`		`- ([=] { std::layout_left::mapping<std::extents<char, D, 5>> m(arg); }()),`
	`58`	`+ ([=] { std::layout_left::mapping<std::extents<signed char, D, 5>> m(arg); }()),`
`56`	`59`	`"layout_left::mapping converting ctor: other.required_span_size() must be representable as index_type.");`
`57`	`60`	`}`
`58`	`61`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,6 @@`
`13`	`13`
`14`	`14`	`// <mdspan>`
`15`	`15`
`16`		`-`
`17`	`16`	`// constexpr mapping(const extents_type& e) noexcept;`
`18`	`17`	`//`
`19`	`18`	`// Preconditions: The size of the multidimensional index space e is representable as a value of type index_type ([basic.fundamental]).`
`@@ -32,7 +31,7 @@ int main(int, char**) {`
`32`	`31`	`{`
`33`	`32`	`// the extents are representable but the product is not, so we can't use it for layout_left`
`34`	`33`	`TEST_LIBCPP_ASSERT_FAILURE(`
`35`		`- ([=] { std::layout_left::mapping<std::extents<char, D, 5>> m(std::extents<char, D, 5>(100)); }()),`
	`34`	`+ ([=] { std::layout_left::mapping<std::extents<signed char, D, 5>> m(std::extents<signed char, D, 5>(100)); }()),`
`36`	`35`	`"layout_left::mapping extents ctor: product of extents must be representable as index_type.");`
`37`	`36`	`}`
`38`	`37`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -44,9 +44,12 @@ int main(int, char**) {`
`44`	`44`	`}`
`45`	`45`	`// non-representability of extents itself`
`46`	`46`	`{`
`47`		`- TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_left::mapping<std::extents<char, D>> m(`
`48`		`- std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(500))); }()),`
`49`		`- "extents ctor: arguments must be representable as index_type and nonnegative");`
	`47`	`+ TEST_LIBCPP_ASSERT_FAILURE(`
	`48`	`+ ([=] {`
	`49`	`+ std::layout_left::mapping<std::extents<signed char, D>> m(`
	`50`	`+ std::layout_right::mapping<std::extents<int, D>>(std::extents<int, D>(500)));`
	`51`	`+ }()),`
	`52`	`+ "extents ctor: arguments must be representable as index_type and nonnegative");`
`50`	`53`	`}`
`51`	`54`
`52`	`55`	`// Can't trigger required_span_size() representability assertion, since for rank-1 the above check will trigger first,`
Original file line number	Diff line number	Diff line change
`@@ -54,14 +54,14 @@ int main(int, char**) {`
`54`	`54`	`// non-representability of extents itself`
`55`	`55`	`{`
`56`	`56`	`std::layout_stride::mapping arg(std::extents<int, D>(500), std::array<int, 1>{1});`
`57`		`- TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_left::mapping<std::extents<char, D>> m(arg); }()),`
	`57`	`+ TEST_LIBCPP_ASSERT_FAILURE(([=] { std::layout_left::mapping<std::extents<signed char, D>> m(arg); }()),`
`58`	`58`	`"extents ctor: arguments must be representable as index_type and nonnegative");`
`59`	`59`	`}`
`60`	`60`	`// non-representability of required span size`
`61`	`61`	`{`
`62`	`62`	`std::layout_stride::mapping arg(std::extents<int, D, D>(100, 3), std::array<int, 2>{1, 100});`
`63`	`63`	`TEST_LIBCPP_ASSERT_FAILURE(`
`64`		`- ([=] { std::layout_left::mapping<std::extents<char, D, D>> m(arg); }()),`
	`64`	`+ ([=] { std::layout_left::mapping<std::extents<signed char, D, D>> m(arg); }()),`
`65`	`65`	`"layout_left::mapping from layout_stride ctor: other.required_span_size() must be "`
`66`	`66`	`"representable as index_type.");`
`67`	`67`	`}`