Implement LWG3101 - span's Container constructors need another constraint

[mclow.lists]

Summary

See https://wg21.link/LWG3101

Another issue that is due to be voted on in Kona.
Since we have two implementations of span - one for dynamic extents, and one for static, this was simple.

[ldionne]

test/std/containers/views/span.cons/container.fail.cpp

72

Why does this fail? Shouldn't this use std::span<int, std::dynamic_extent>::span(Container const&)?

100

Just to make sure I understand -- this is the only test that checks the actual changes in LWG3101, i.e. the removal of support for constructing a statically-sized std::span from a dynamically-sized std::span. Other changes just remove tests that shouldn't be passing (or don't make sense) anymore.

[mclow.lists]

test/std/containers/views/span.cons/container.fail.cpp

72

Because it's an rvalue? Dunno; but if so, that makes all the other tests useless. I will investigate.

100

Correct. I removed all the different combinations of const/non-const etc because I removed the ctor, and left a single test behind to make sure that the ctor is not found.

[ldionne]

This LGTM but I'd like to understand the situation I commented on with the rvalue before we commit this.

test/std/containers/views/span.cons/container.fail.cpp

72

I think it should compile because the Container const& will bind to a rvalue (and then the std::span contains a dangling reference).

[mclow.lists]

test/std/containers/views/span.cons/container.fail.cpp

72

If I was creating a span<const int>, then yes, but not a span<int>

[mclow.lists]

Re-gen the diff after I updated the tests based on Louis' comments (see r351887)

[ldionne]

LGTM, thanks for the explanation re: the test.

[mclow.lists]

Committed as 354805

include/span

     _LIBCPP_INLINE_VISIBILITY constexpr span(      array<value_type, _Extent>& __arr) noexcept : __data{__arr.data()} {}
     _LIBCPP_INLINE_VISIBILITY constexpr span(const array<value_type, _Extent>& __arr) noexcept : __data{__arr.data()} {}
 
-    template <class _Container>
-    inline _LIBCPP_INLINE_VISIBILITY
-        constexpr span(      _Container& __c,
-            enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr)
-        : __data{_VSTD::data(__c)}
-        { _LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (container)"); }
-
-    template <class _Container>
-    inline _LIBCPP_INLINE_VISIBILITY
-        constexpr span(const _Container& __c,
-            enable_if_t<__is_span_compatible_container<const _Container, _Tp>::value, nullptr_t> = nullptr)
-        : __data{_VSTD::data(__c)}
-        { _LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (const container)"); }
-
     template <class _OtherElementType>
     inline _LIBCPP_INLINE_VISIBILITY
         constexpr span(const span<_OtherElementType, _Extent>& __other,

test/std/containers/views/span.cons/container.fail.cpp

 //     constexpr span(const Container& cont);
 //
 // Remarks: These constructors shall not participate in overload resolution unless:
+//   — extent == dynamic_extent,
 //   — Container is not a specialization of span,
 //   — Container is not a specialization of array,
 //   — is_array_v<Container> is false,

 //  Making non-const spans from const sources (a temporary binds to `const &`)
     {
     std::span<int>    s1{IsAContainer<int>()};          // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s2{IsAContainer<int>()};          // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}} 
     std::span<int>    s3{std::vector<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s4{std::vector<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}} 
     }
 
 //  Missing size and/or data
     {
     std::span<const int>    s1{NotAContainerNoData<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const int, 0> s2{NotAContainerNoData<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
     std::span<const int>    s3{NotAContainerNoSize<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const int, 0> s4{NotAContainerNoSize<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
     std::span<const int>    s5{NotAContainerPrivate<int>()};  // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const int, 0> s6{NotAContainerPrivate<int>()};  // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
 
 //  Again with the standard containers
     std::span<const int>    s11{std::deque<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const int, 0> s12{std::deque<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
     std::span<const int>    s13{std::list<int>()};            // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const int, 0> s14{std::list<int>()};            // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
     std::span<const int>    s15{std::forward_list<int>()};    // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const int, 0> s16{std::forward_list<int>()};    // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
     }
 
 //  Not the same type

     {
     IsAContainer<int> c;
     std::span<float>    s1{c};   // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
-    std::span<float, 0> s2{c};   // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
     }
 
-//  CV wrong (dynamically sized)
+//  CV wrong
     {
     IsAContainer<const          int> c;
     IsAContainer<const volatile int> cv;

     std::span<      volatile int> s7{cv};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
     }
 
-//  CV wrong (statically sized)
+//  statically sized
     {
-    IsAContainer<const          int> c;
-    IsAContainer<const volatile int> cv;
-    IsAContainer<      volatile int> v;
-
-    std::span<               int,1> s1{c};  // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
-    std::span<               int,1> s2{v};  // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
-    std::span<               int,1> s3{cv}; // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
-    std::span<const          int,1> s4{v};  // expected-error {{no matching constructor for initialization of 'std::span<const int, 1>'}}
-    std::span<const          int,1> s5{cv}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 1>'}}
-    std::span<      volatile int,1> s6{c};  // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 1>'}}
-    std::span<      volatile int,1> s7{cv}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 1>'}}
+    IsAContainer<int> c;
+    std::span<int,1> s1{c}; // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
     }
-
 }

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

 //     constexpr span(const Container& cont);
 //
 // Remarks: These constructors shall not participate in overload resolution unless:
+//   — extent == dynamic_extent,
 //   — Container is not a specialization of span,
 //   — Container is not a specialization of array,
 //   — is_array_v<Container> is false,

 {
     std::vector<int> v  = {1,2,3};
 
-//  Types the same (dynamic sized)
+//  Types the same
     {
     std::span<               int> s1{v};    // a span<               int> pointing at int.
     }
 
-//  Types the same (static sized)
+//  types different
     {
-    std::span<               int,3> s1{v};  // a span<               int> pointing at int.
-    }
-
-//  types different (dynamic sized)
-    {
     std::span<const          int> s1{v};    // a span<const          int> pointing at int.
     std::span<      volatile int> s2{v};    // a span<      volatile int> pointing at int.
     std::span<      volatile int> s3{v};    // a span<      volatile int> pointing at const int.

     std::span<const volatile int> s4{v};    // a span<const volatile int> pointing at int.
     }
 
-//  types different (static sized)
-    {
-    std::span<const          int,3> s1{v};  // a span<const          int> pointing at int.
-    std::span<      volatile int,3> s2{v};  // a span<      volatile int> pointing at int.
-    std::span<      volatile int,3> s3{v};  // a span<      volatile int> pointing at const int.
-    std::span<const volatile int,3> s4{v};  // a span<const volatile int> pointing at int.
-    }
-
 //  Constructing a const view from a temporary
     {
     std::span<const int>    s1{IsAContainer<int>()};
-    std::span<const int, 0> s2{IsAContainer<int>()};
     std::span<const int>    s3{std::vector<int>()};
-    std::span<const int, 0> s4{std::vector<int>()};
     (void) s1;
-    (void) s2;
     (void) s3;
-    (void) s4;
     }
 }
 

 constexpr bool testConstexprSpan()
 {
     constexpr IsAContainer<const T> val{};
-    std::span<const T>    s1{val};
-    std::span<const T, 1> s2{val};
-    return
-        s1.data() == val.getV() && s1.size() == 1
-    &&  s2.data() == val.getV() && s2.size() == 1;
+    std::span<const T> s1{val};
+    return s1.data() == val.getV() && s1.size() == 1;
 }
 
 

     const IsAContainer<T> cVal;
     std::span<T>          s1{val};
     std::span<const T>    s2{cVal};
-    std::span<T, 1>       s3{val};
-    std::span<const T, 1> s4{cVal};
     assert(s1.data() == val.getV()  && s1.size() == 1);
     assert(s2.data() == cVal.getV() && s2.size() == 1);
-    assert(s3.data() == val.getV()  && s3.size() == 1);
-    assert(s4.data() == cVal.getV() && s4.size() == 1);
 }
 
 struct A{};