[libc++] Implement LWG3369, tweak CTAD for std::span.

[• Quuxplusone]

Summary

The original bug doesn't reproduce on Clang, allegedly because of
https://bugs.llvm.org/show_bug.cgi?id=44484
We already test STL's exact test case, in span.cons/deduct.pass.cpp, which I'm touching just for the heck of it.

[jloser]

LGTM - thanks for looking into it.

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

9

We could do a similar thing for all the files I touched in my recent span PR FYI. We're going to drop support for AppleClang 12.0.0 officially in BuildKite hopefully soon since we only need to support AppleClang 13.0.0 technically. At that point, all the UNSUPPORTED: libcpp-no-concepts go away.

[Mordante]

Can you add a test for the fix. For example STL's example in LWG3369? Or does the Clang bug prevent us from testing it?

[• Quuxplusone]

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

56–58

@Mordante: I believe this is the exact test case displayed in https://cplusplus.github.io/LWG/issue3369 — and yeah, I assume it passes anyway because of that Clang bug. I don't have the capability to test libc++ with non-Clang compilers to see if it fails... although I confess I don't understand why this test passes even with the gcc buildkite.

[Mordante]

LGTM!

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

56–58

That's indeed the same test.

[ldionne]

I guess that means we are forward-compatible with Clang once they fix PR44484. Let's ship this.

libcxx/docs/Status/Cxx20Issues.csv

 "`3356 <https://wg21.link/LWG3356>`__","``__cpp_lib_nothrow_convertible``\  should be ``__cpp_lib_is_nothrow_convertible``\ ","Prague","|Complete|","12.0"
 "`3358 <https://wg21.link/LWG3358>`__","|sect|\ [span.cons] is mistaken that ``to_address``\  can throw","Prague","",""
 "`3359 <https://wg21.link/LWG3359>`__","``<chrono>``\  leap second support should allow for negative leap seconds","Prague","","","|chrono|"
 "`3360 <https://wg21.link/LWG3360>`__","``three_way_comparable_with``\  is inconsistent with similar concepts","Prague","","","|spaceship|"
 "`3362 <https://wg21.link/LWG3362>`__","Strike ``stop_source``\ 's ``operator!=``\ ","Prague","",""
 "`3363 <https://wg21.link/LWG3363>`__","``drop_while_view``\  should opt-out of ``sized_range``\ ","Prague","","","|ranges|"
 "`3364 <https://wg21.link/LWG3364>`__","Initialize data members of ranges and their iterators","Prague","","","|ranges|"
 "`3367 <https://wg21.link/LWG3367>`__","Integer-class conversions should not throw","Prague","",""
-"`3369 <https://wg21.link/LWG3369>`__","``span``\ 's deduction-guide for built-in arrays doesn't work","Prague","",""
+"`3369 <https://wg21.link/LWG3369>`__","``span``\ 's deduction-guide for built-in arrays doesn't work","Prague","|Complete|","14.0"
 "`3371 <https://wg21.link/LWG3371>`__","``visit_format_arg``\  and ``make_format_args``\  are not hidden friends","Prague","|Complete|","14.0","|format|"
 "`3372 <https://wg21.link/LWG3372>`__","``vformat_to``\  should not try to deduce ``Out``\  twice","Prague","","","|format|"
 "`3373 <https://wg21.link/LWG3373>`__","``{to,from}_chars_result``\  and ``format_to_n_result``\  need the  ""we really mean what we say"" wording","Prague","","","|format|"
 "`3374 <https://wg21.link/LWG3374>`__","P0653 + P1006 should have made the other ``std::to_address``\  overload ``constexpr``\ ","Prague","|Complete|","12.0"
 "`3375 <https://wg21.link/LWG3375>`__","``decay``\  in ``viewable_range``\  should be ``remove_cvref``\ ","Prague","","","|ranges|"
 "`3377 <https://wg21.link/LWG3377>`__","``elements_view::iterator``\  befriends a specialization of itself","Prague","","","|ranges|"
 "`3379 <https://wg21.link/LWG3379>`__","""``safe``\ "" in several library names is misleading","Prague","|In Progress|",""
 "`3380 <https://wg21.link/LWG3380>`__","``common_type``\  and comparison categories","Prague","","","|spaceship|"

libcxx/include/span

public:
 
     // [span.cons], span constructors, copy, assignment, and destructor
     constexpr span() noexcept;
     template <class It>
     constexpr explicit(Extent != dynamic_extent) span(It first, size_type count);
     template <class It, class End>
     constexpr explicit(Extent != dynamic_extent) span(It first, End last);
     template <size_t N>
-        constexpr span(element_type (&arr)[N]) noexcept;
+        constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
     template <size_t N>
         constexpr span(array<value_type, N>& arr) noexcept;
     template <size_t N>
         constexpr span(const array<value_type, N>& arr) noexcept;
     template<class R>
       constexpr explicit(Extent != dynamic_extent) span(R&& r);
     constexpr span(const span& other) noexcept = default;
     template <class OtherElementType, size_t OtherExtent>
#if !defined(_LIBCPP_HAS_NO_RANGES)
     constexpr explicit span(_It __first, _End __last) : __data{_VSTD::to_address(__first)} {
       (void)__last;
       _LIBCPP_ASSERT((__last - __first >= 0), "invalid range in span's constructor (iterator, sentinel)");
       _LIBCPP_ASSERT(__last - __first == _Extent,
                      "invalid range in span's constructor (iterator, sentinel): last - first != extent");
     }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY constexpr span(element_type (&__arr)[_Extent])          noexcept : __data{__arr} {}
+    _LIBCPP_INLINE_VISIBILITY constexpr span(type_identity_t<element_type> (&__arr)[_Extent]) noexcept : __data{__arr} {}
 
     template <class _OtherElementType,
               enable_if_t<is_convertible_v<_OtherElementType(*)[], element_type (*)[]>, nullptr_t> = nullptr>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}
 
     template <class _OtherElementType,
               enable_if_t<is_convertible_v<const _OtherElementType(*)[], element_type (*)[]>, nullptr_t> = nullptr>
template <
                     nullptr_t> = nullptr>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(_It __first, _End __last)
         : __data(_VSTD::to_address(__first)), __size(__last - __first) {}
 #endif
 
     template <size_t _Sz>
     _LIBCPP_INLINE_VISIBILITY
-    constexpr span(element_type (&__arr)[_Sz])          noexcept : __data{__arr}, __size{_Sz} {}
+    constexpr span(type_identity_t<element_type> (&__arr)[_Sz]) noexcept : __data{__arr}, __size{_Sz} {}
 
     template <class _OtherElementType, size_t _Sz,
               enable_if_t<is_convertible_v<_OtherElementType(*)[], element_type (*)[]>, nullptr_t> = nullptr>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
 
     template <class _OtherElementType, size_t _Sz,
               enable_if_t<is_convertible_v<const _OtherElementType(*)[], element_type (*)[]>, nullptr_t> = nullptr>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// AppleClang 12.0.0 doesn't fully support ranges/concepts
-// XFAIL: apple-clang-12.0.0
-
 // <span>
 
 //   template<class It, class EndOrSize>
 //     span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;
 //
 //   template<class T, size_t N>
 //     span(T (&)[N]) -> span<T, N>;
 //
void test_iterator_sentinel() {
   ASSERT_SAME_TYPE(decltype(s), std::span<int>);
   assert(s.size() == std::size(arr));
   assert(s.data() == std::data(arr));
   }
 }
 
 void test_c_array() {
     {
     int arr[] = {1, 2, 3};
     std::span s{arr};
     ASSERT_SAME_TYPE(decltype(s), std::span<int, 3>);
     assert(s.size() == std::size(arr));
     assert(s.data() == std::data(arr));
     }
 
     {
     const int arr[] = {1,2,3};
     std::span s{arr};
     ASSERT_SAME_TYPE(decltype(s), std::span<const int, 3>);