[libcxx][span] Remove tuple interface

[miscco]

Summary

This implements P2116 by removing the tuple interface from std::span

[miscco]

ping

[miscco]

Ping, this is also all red

[miscco]

Ping

[miscco]

Thanks for the review, could somebody commit it as I do not have the rights

libcxx/include/span

// [span.iter], span iterator support
     _LIBCPP_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writable_bytes() const noexcept
     { return {reinterpret_cast<byte *>(data()), size_bytes()}; }
 
 private:
     pointer   __data;
     size_type __size;
 };
 
-//  tuple interface
-template <class _Tp, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS tuple_size<span<_Tp, _Size>>
-    : public integral_constant<size_t, _Size> {};
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_size<span<_Tp, dynamic_extent>>; // declared but not defined
-
-
-template <size_t _Ip, class _Tp, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, span<_Tp, _Size>>
-{
-    static_assert( dynamic_extent != _Size, "std::tuple_element<> not supported for std::span<T, dynamic_extent>");
-    static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::span)");
-    typedef _Tp type;
-};
-
-template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY constexpr
-_Tp&
-get(span<_Tp, _Size> __s) noexcept
-{
-    static_assert( dynamic_extent != _Size, "std::get<> not supported for std::span<T, dynamic_extent>");
-    static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::span)");
-    return __s[_Ip];
-}
-
-
 //  as_bytes & as_writable_bytes
 template <class _Tp, size_t _Extent>
 _LIBCPP_INLINE_VISIBILITY
 auto as_bytes(span<_Tp, _Extent> __s) noexcept
 -> decltype(__s.__as_bytes())
 { return    __s.__as_bytes(); }
 
 template <class _Tp, size_t _Extent>

libcxx/test/std/containers/views/span.tuple/get.fail.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++98, c++03, c++11, c++14, c++17
-
-// <span>
-
-// template <size_t _Ip, ElementType, size_t Extent>
-//   constexpr ElementType& get(span<ElementType, Extent> s) noexcept;
-
-#include <span>
-
-#include "test_macros.h"
-
-
-int main(int, char**)
-{
-//  No get for dynamic spans
-    constexpr int arr [] = {0,1,2,3,4,5,6,7,8,9};
-    (void) std::get< 0>(std::span<const int,  0>(arr, (size_t)0)); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Index out of bounds in std::get<> (std::span)"}}
-    (void) std::get< 5>(std::span<const int,  5>(arr,         5)); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Index out of bounds in std::get<> (std::span)"}}
-    (void) std::get<20>(std::span<const int, 10>(arr,        10)); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Index out of bounds in std::get<> (std::span)"}}
-
-  return 0;
-}

libcxx/test/std/containers/views/span.tuple/get.pass.cpp

-// -*- C++ -*-
-//===------------------------------ span ---------------------------------===//
-//
-// 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++98, c++03, c++11, c++14, c++17
-
-// <span>
-
-// template <size_t _Ip, ElementType, size_t Extent>
-//   constexpr ElementType& get(span<ElementType, Extent> s) noexcept;
-//
-
-
-#include <span>
-#include <cassert>
-#include <string>
-
-#include "test_macros.h"
-
-
-template <size_t Idx, typename Span>
-constexpr bool testConstexprSpan(Span sp, typename Span::pointer ptr)
-{
-    ASSERT_NOEXCEPT(std::get<Idx>(sp));
-    return std::addressof(std::get<Idx>(sp)) == ptr;
-}
-
-
-template <size_t Idx, typename Span>
-void testRuntimeSpan(Span sp, typename Span::pointer ptr)
-{
-    ASSERT_NOEXCEPT(std::get<Idx>(sp));
-    assert(std::addressof(std::get<Idx>(sp)) == ptr);
-}
-
-struct A{};
-constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
-          int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
-
-int main(int, char**)
-{
-
-//  static size
-    static_assert(testConstexprSpan<0>(std::span<const int, 4>(iArr1, 4), iArr1 + 0), "");
-    static_assert(testConstexprSpan<1>(std::span<const int, 4>(iArr1, 4), iArr1 + 1), "");
-    static_assert(testConstexprSpan<2>(std::span<const int, 4>(iArr1, 4), iArr1 + 2), "");
-    static_assert(testConstexprSpan<3>(std::span<const int, 4>(iArr1, 4), iArr1 + 3), "");
-
-    static_assert(testConstexprSpan<0>(std::span<const int, 1>(iArr1 + 1, 1), iArr1 + 1), "");
-    static_assert(testConstexprSpan<1>(std::span<const int, 2>(iArr1 + 2, 2), iArr1 + 3), "");
-    static_assert(testConstexprSpan<2>(std::span<const int, 3>(iArr1 + 3, 3), iArr1 + 5), "");
-    static_assert(testConstexprSpan<3>(std::span<const int, 4>(iArr1 + 4, 4), iArr1 + 7), "");
-
-//  static size
-    testRuntimeSpan<0>(std::span<int, 4>(iArr2, 4), iArr2);
-    testRuntimeSpan<1>(std::span<int, 4>(iArr2, 4), iArr2 + 1);
-    testRuntimeSpan<2>(std::span<int, 4>(iArr2, 4), iArr2 + 2);
-    testRuntimeSpan<3>(std::span<int, 4>(iArr2, 4), iArr2 + 3);
-
-    testRuntimeSpan<0>(std::span<int, 1>(iArr2 + 1, 1), iArr2 + 1);
-    testRuntimeSpan<1>(std::span<int, 2>(iArr2 + 2, 2), iArr2 + 3);
-    testRuntimeSpan<2>(std::span<int, 3>(iArr2 + 3, 3), iArr2 + 5);
-    testRuntimeSpan<3>(std::span<int, 4>(iArr2 + 4, 4), iArr2 + 7);
-
-
-    std::string s;
-    testRuntimeSpan<0>(std::span<std::string, 1>(&s, 1), &s);
-
-
-  return 0;
-}

libcxx/test/std/containers/views/span.tuple/tuple_element.fail.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++98, c++03, c++11, c++14, c++17
-
-// <span>
-
-// tuple_element<I, span<T, N> >::type
-
-#include <span>
-
-#include "test_macros.h"
-
-
-int main(int, char**)
-{
-//  No tuple_element for dynamic spans
-    using T1 = typename std::tuple_element< 0, std::span<int,  0>>::type; // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Index out of bounds in std::tuple_element<> (std::span)"}}
-    using T2 = typename std::tuple_element< 5, std::span<int,  5>>::type; // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Index out of bounds in std::tuple_element<> (std::span)"}}
-    using T3 = typename std::tuple_element<20, std::span<int, 10>>::type; // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Index out of bounds in std::tuple_element<> (std::span)"}}
-
-    return 0;
-}

libcxx/test/std/containers/views/span.tuple/tuple_element.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++98, c++03, c++11, c++14, c++17
-
-// <span>
-
-// tuple_element<I, span<T, N> >::type
-
-#include <span>
-
-#include "test_macros.h"
-
-template <class T, std::size_t N, std::size_t Idx>
-void test()
-{
-    {
-    typedef std::span<T, N> C;
-    ASSERT_SAME_TYPE(typename std::tuple_element<Idx, C>::type, T);
-    }
-    {
-    typedef std::span<T const, N> C;
-    ASSERT_SAME_TYPE(typename std::tuple_element<Idx, C>::type, T const);
-    }
-    {
-    typedef std::span<T volatile, N> C;
-    ASSERT_SAME_TYPE(typename std::tuple_element<Idx, C>::type, T volatile);
-    }
-    {
-    typedef std::span<T const volatile, N> C;
-    ASSERT_SAME_TYPE(typename std::tuple_element<Idx, C>::type, T const volatile);
-    }
-}
-
-int main(int, char**)
-{
-    test<double, 3, 0>();
-    test<double, 3, 1>();
-    test<double, 3, 2>();
-
-    test<int, 5, 0>();
-    test<int, 5, 1>();
-    test<int, 5, 2>();
-    test<int, 5, 3>();
-    test<int, 5, 4>();
-
-  return 0;
-}

libcxx/test/std/containers/views/span.tuple/tuple_size.fail.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++98, c++03, c++11, c++14, c++17
-
-// <span>
-
-// tuple_size<span<T, N> >::value
-
-#include <span>
-
-int main(int, char**)
-{
-    (void) std::tuple_size<std::span<double>>::value; // expected-error-re {{implicit instantiation of undefined template 'std:{{.*}}:tuple_size<std:{{.*}}:span<double, {{.*}}}}
-    (void) std::tuple_size<std::span<int>>::value;    // expected-error-re {{implicit instantiation of undefined template 'std:{{.*}}:tuple_size<std:{{.*}}:span<int, {{.*}}}}
-    return 0;
-}

libcxx/test/std/containers/views/span.tuple/tuple_size.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-
-// <span>
-
-// tuple_size<span<T, N> >::value
-
-#include <span>
-
-#include "test_macros.h"
-
-template <class T, std::size_t N>
-void test()
-{
-    {
-    typedef std::span<T, N> C;
-    static_assert((std::tuple_size<C>::value == N), "");
-    }
-    {
-    typedef std::span<T const, N> C;
-    static_assert((std::tuple_size<C>::value == N), "");
-    }
-    {
-    typedef std::span<T volatile, N> C;
-    static_assert((std::tuple_size<C>::value == N), "");
-    }
-    {
-    typedef std::span<T const volatile, N> C;
-    static_assert((std::tuple_size<C>::value == N), "");
-    }
-}
-
-int main(int, char**)
-{
-    test<double, 0>();
-    test<double, 3>();
-    test<double, 5>();
-
-  return 0;
-}

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P1994">P1994</a></td><td>LWG</td><td>elements_view needs its own sentinel</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P2002">P2002</a></td><td>CWG</td><td>Defaulted comparison specification cleanups</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P2045">P2045</a></td><td>LWG</td><td>Missing Mandates for the standard library</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P2085">P2085</a></td><td>CWG</td><td>Consistent defaulted comparisons</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P2091">P2091</a></td><td>LWG</td><td>Issues with range access CPOs</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P2101">P2101</a></td><td>LWG</td><td>'Models' subsumes 'satisfies' (Wording for US298 and US300)</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P2102">P2102</a></td><td>LWG</td><td>Make 'implicit expression variations' more explicit (Wording for US185)</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P2106">P2106</a></td><td>LWG</td><td>Alternative wording for GB315 and GB316</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2116">P2116</a></td><td>LWG</td><td>Remove tuple-like protocol support from fixed-extent span</td><td>Prague</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P2116">P2116</a></td><td>LWG</td><td>Remove tuple-like protocol support from fixed-extent span</td><td>Prague</td><td>Complete</td><td>11.0</td></tr>
 <!--   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
   </table>
 
 <p><i>[ Note: "Nothing to do" means that no library changes were needed to implement this change -- end note]</i></p>
 
 <p>The missing bits in P0600 are in [mem.res.class], [mem.poly.allocator.class], and [container.node.overview]</p>
 
 <p>The missing bits in P0202 are in <tt>copy</tt>, <tt>copy_backwards</tt>, <tt>move</tt>, and <tt>move_backwards</tt> (and the ones that call them: <tt>copy_n</tt>, <tt>rotate_copy</tt>, <tt>merge</tt>, <tt>set_union</tt>, <tt>set_difference</tt>, and <tt>set_symmetric_difference</tt>). This is because the first four algorithms have specializations that call <tt>memmove</tt> which is not constexpr. See <a href="https://bugs.llvm.org/show_bug.cgi?id=25165">Bug 25165</a></p>