Missing inclusion and test skipping

Author: frederick-vs-ja

libcxx/include/__iterator/const_iterator.h

@@ -12,6 +12,7 @@
 
 #include <__compare/three_way_comparable.h>
 #include <__concepts/common_with.h>
+#include <__concepts/constructible.h>
 #include <__concepts/convertible_to.h>
 #include <__concepts/different_from.h>
 #include <__concepts/same_as.h>
@@ -29,6 +30,7 @@
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_specialization.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 

libcxx/include/__ranges/access.h

@@ -18,6 +18,7 @@
 #include <__memory/pointer_traits.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__type_traits/decay.h>
+#include <__type_traits/is_object.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cvref.h>

libcxx/include/__ranges/as_const_view.h

@@ -20,8 +20,11 @@
 #include <__ranges/ref_view.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/is_reference.h>
 #include <__type_traits/is_specialization.h>
 #include <__utility/auto_cast.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <cstddef>

libcxx/test/std/containers/views/views.span/span.cons/copy.pass.cpp

@@ -87,14 +87,17 @@ constexpr bool test_all() {
   test<volatile double>();
   test<const volatile double>();
 
-  // Note: Can't test non-fundamental types with volatile because we require `T*` to be indirectly_readable,
-  //       which isn't the case when T is volatile.
+  // Note: Can't test class types with volatile because we require `T*` to be indirectly_readable,
+  //       which isn't the case when T is volatile. See also LWG3813.
   test<Foo>();
   test<const Foo>();
 
   test<std::string>();
   test<const std::string>();
 
+#if defined(_LIBCPP_VERSION) && TEST_STD_VER < 23
+  // libc++ supports span<Incomplete> as an extension in C++20 mode,
+  // but the extension is incompatible with changes of span in C++23.
   // Regression test for https://github.com/llvm/llvm-project/issues/104496
   {
     struct Incomplete;
@@ -103,6 +106,7 @@ constexpr bool test_all() {
     assert(copy.data() == x.data());
     assert(copy.size() == x.size());
   }
+#endif
 
   return true;
 }

libcxx/test/std/containers/views/views.span/span.cons/span.pass.cpp

@@ -87,11 +87,16 @@ TEST_CONSTEXPR_CXX20 void check() {
 }
 
 template <class T>
-TEST_CONSTEXPR_CXX20 void check_cvs() {
+constexpr void check_non_volatile() {
   check<T, T>();
 
   check<T const, T>();
   check<T const, T const>();
+}
+
+template <class T>
+constexpr void check_cvs() {
+  check_non_volatile<T>();
 
   check<T volatile, T>();
   check<T volatile, T volatile>();
@@ -104,12 +109,17 @@ TEST_CONSTEXPR_CXX20 void check_cvs() {
 
 struct A {};
 
-TEST_CONSTEXPR_CXX20 bool test() {
+constexpr bool test() {
   check_cvs<int>();
   check_cvs<long>();
   check_cvs<double>();
+#if TEST_STD_VER >= 23 // LWG3813: span<volatile class> is generally unsupported since C++23.
+  check_non_volatile<std::string>();
+  check_non_volatile<A>();
+#else
   check_cvs<std::string>();
   check_cvs<A>();
+#endif
   return true;
 }
 

libcxx/test/std/containers/views/views.span/types.pass.cpp

@@ -66,30 +66,39 @@ void testSpan()
     testIterator<S, typename S::reverse_iterator>();
 }
 
+template <typename T>
+void test_non_volatile() {
+  testSpan<std::span<T>, T, std::dynamic_extent>();
+  testSpan<std::span<const T>, const T, std::dynamic_extent>();
+
+  testSpan<std::span<T, 5>, T, 5>();
+  testSpan<std::span<const T, 5>, const T, 5>();
+}
 
 template <typename T>
-void test()
-{
-    testSpan<std::span<               T>,                T, std::dynamic_extent>();
-    testSpan<std::span<const          T>, const          T, std::dynamic_extent>();
-    testSpan<std::span<      volatile T>,       volatile T, std::dynamic_extent>();
-    testSpan<std::span<const volatile T>, const volatile T, std::dynamic_extent>();
-
-    testSpan<std::span<               T, 5>,                T, 5>();
-    testSpan<std::span<const          T, 5>, const          T, 5>();
-    testSpan<std::span<      volatile T, 5>,       volatile T, 5>();
-    testSpan<std::span<const volatile T, 5>, const volatile T, 5>();
+void test() {
+  test_non_volatile<T>();
+
+  testSpan<std::span<volatile T>, volatile T, std::dynamic_extent>();
+  testSpan<std::span<const volatile T>, const volatile T, std::dynamic_extent>();
+
+  testSpan<std::span<volatile T, 5>, volatile T, 5>();
+  testSpan<std::span<const volatile T, 5>, const volatile T, 5>();
 }
 
-struct A{};
+struct A {};
 
-int main(int, char**)
-{
-    test<int>();
-    test<long>();
-    test<double>();
-    test<std::string>();
-    test<A>();
+int main(int, char**) {
+  test<int>();
+  test<long>();
+  test<double>();
+#if TEST_STD_VER >= 23 // LWG3813: span<volatile class> is generally unsupported since C++23.
+  test_non_volatile<std::string>();
+  test_non_volatile<A>();
+#else
+  test<std::string>();
+  test<A>();
+#endif
 
   return 0;
 }