[libc++] [test] Add tests for std::span construction from various initializer lists.

[• Quuxplusone]

Summary

This is related to P2447 "std::span<const T> should be constructible from std::initializer_list<T>," but doesn't implement the proposal — instead, it simply adds test coverage for the bits that would change as a result of the proposal (and also for some bits that wouldn't change, but are related and lack any test coverage today).

(I'm hoping this can be rubberstamped, but will still wait for CI to come back and be green before I land it.)

[ldionne]

Please rebase onto main to trigger CI. Thanks for adding this coverage.

[• Quuxplusone]

Poke buildkite

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

//  types different (static sized)
     std::span<      volatile int,3> s3{ arr};   // a span<      volatile int> pointing at const int.
     std::span<const volatile int,3> s4{ arr};   // a span<const volatile int> pointing at int.
     std::span<const volatile int,3> s5{carr};   // a span<const volatile int> pointing at const int.
     std::span<const volatile int,3> s6{varr};   // a span<const volatile int> pointing at volatile int.
     assert(s1.size() + s2.size() + s3.size() + s4.size() + s5.size() + s6.size() == 18);
     }
 }
 
-
-template <typename T>
-constexpr bool testConstexprSpan()
+template<class T>
+constexpr bool testSpan()
 {
-    constexpr T val[2] = {};
+    T val[2] = {};
 
-    ASSERT_NOEXCEPT(std::span<const T>   {val});
+    ASSERT_NOEXCEPT(std::span<T>{val});
+    ASSERT_NOEXCEPT(std::span<T, 2>{val});
+    ASSERT_NOEXCEPT(std::span<const T>{val});
     ASSERT_NOEXCEPT(std::span<const T, 2>{val});
-    std::span<const T>    s1{val};
-    std::span<const T, 2> s2{val};
-    return
-        s1.data() == &val[0] && s1.size() == 2
-    &&  s2.data() == &val[0] && s2.size() == 2;
-}
 
+    std::span<T> s1 = val;
+    std::span<T, 2> s2 = val;
+    std::span<const T> s3 = val;
+    std::span<const T, 2> s4 = val;
+    assert(s1.data() == val && s1.size() == 2);
+    assert(s2.data() == val && s2.size() == 2);
+    assert(s3.data() == val && s3.size() == 2);
+    assert(s4.data() == val && s4.size() == 2);
+
+    std::span<const int> s5 = {{1,2}};
+    std::span<const int, 2> s6 = {{1,2}};
+    assert(s5.size() == 2);  // and it dangles
+    assert(s6.size() == 2);  // and it dangles
 
-template <typename T>
-void testRuntimeSpan()
-{
-    T val[2] = {};
-    ASSERT_NOEXCEPT(std::span<T>   {val});
-    ASSERT_NOEXCEPT(std::span<T, 2>{val});
-    std::span<T>    s1{val};
-    std::span<T, 2> s2{val};
-    assert(s1.data() == &val[0] && s1.size() == 2);
-    assert(s2.data() == &val[0] && s2.size() == 2);
+    return true;
 }
 
-struct A{};
+
+struct A {};
 
 int main(int, char**)
 {
-    static_assert(testConstexprSpan<int>(),    "");
-    static_assert(testConstexprSpan<long>(),   "");
-    static_assert(testConstexprSpan<double>(), "");
-    static_assert(testConstexprSpan<A>(),      "");
-
-    testRuntimeSpan<int>();
-    testRuntimeSpan<long>();
-    testRuntimeSpan<double>();
-    testRuntimeSpan<std::string>();
-    testRuntimeSpan<A>();
+    testSpan<int>();
+    testSpan<double>();
+    testSpan<A>();
+    testSpan<std::string>();
+
+    static_assert(testSpan<int>());
+    static_assert(testSpan<double>());
+    static_assert(testSpan<A>());
 
     checkCV();
 
     return 0;
 }

libcxx/test/std/containers/views/span.cons/initializer_list.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
+
+// <span>
+
+#include <span>
+#include <cassert>
+
+struct Sink {
+    constexpr Sink() = default;
+    constexpr Sink(Sink*) {}
+};
+
+constexpr int count(std::span<const Sink> sp) {
+    return sp.size();
+}
+
+template<int N>
+constexpr int countn(std::span<const Sink, N> sp) {
+    return sp.size();
+}
+
+constexpr bool test() {
+    Sink a[10];
+    assert(count({a}) == 10);
+    assert(count({a, a+10}) == 10);
+    assert(countn<10>({a}) == 10);
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    static_assert(test());
+
+    return 0;
+}

libcxx/test/std/containers/views/span.cons/iterator_len.verify.cpp

std::span<T, extent> createImplicitSpan(T* ptr, size_t len) {
   return {ptr, len}; // expected-error {{chosen constructor is explicit in copy-initialization}}
 }
 
 int main(int, char**) {
   // explicit constructor necessary
   int arr[] = {1, 2, 3};
   createImplicitSpan<int, 1>(arr, 3);
 
-  std::span<const int> sp = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+  std::span<int> sp = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
+  std::span<int, 2> sp2 = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
+  std::span<const int> csp = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+  std::span<const int, 2> csp2 = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 2>'}}
 
   return 0;
 }