[libc++] Implement P1394r4 for span: range constructor

[jloser]

Summary

Implement https://wg21.link/p1394 which allows span to be constructible
from any contiguous forwarding-range that has a compatible element type.

Fixes https://bugs.llvm.org/show_bug.cgi?id=51443

[jloser]

Use SimpleRange from "simple_range.h" in range.fail.cpp

[• Quuxplusone]

libcxx/include/span

69–71

This ctor should also be conditionally explicit, according to https://eel.is/c++draft/span.cons
[p1394r4] is missing all these explicits for some reason, so eel.is (or whatever copy of the working draft) should be our guide.

179–183

If you're updating these, might as well make them all use e.g.
enable_if_t<!__is_std_span<remove_cvref_t<_Tp>>::value>,

196

If we're assuming Ranges+Concepts support (contiguous_range), then we can use concept instead of inline constexpr bool, and make things maybe very slightly easier on the compiler. However, I'm not sure that we can assume Concepts support; don't we need some #ifdef guards sprinkled through here? Ditto on the deduction guides that use ranges:: things.

Also, the name of this should be something like __is_span_compatible_range; remember this is directly in namespace _VSTD along with everything else in the library, so its name shouldn't be too generic.

433

ADL-proof: _VSTD::to_address, _VSTD::distance. Ditto lines 236, 248.
(The LWG clauses of the Standard have a bad, but at least consistent, pattern, of never writing std:: when it is "obvious." This makes it hard for them to indicate when ADL is actually intended, e.g. on swap; but any time ADL isn't clearly intended, you should always read their foo as std::foo.)

I also (always, but especially here) strongly recommend using () for direct-initialization, never {}. Parens are always correct; braces are sometimes equivalent to parens and sometimes wrong (either because they get hijacked by initializer_list ctors, or because they prohibit narrowing conversions when LWG didn't say to prohibit them).

450–453

Slight scope-creep: For consistency with elsewhere, please rewrite the SFINAE as

template <class _Range, enable_if_t<__is_range_compatible<_Range, element_type>>* = nullptr>

The benefit (in general) is that it's possible to have two overloaded function templates with template-heads

template <class _Range, enable_if_t<A>* = nullptr>
template <class _Range, enable_if_t<B>* = nullptr>

whereas it is not possible to have two overloaded function templates with template-heads

template <class _Range, class = enable_if_t<A>>
template <class _Range, class = enable_if_t<B>>

(because those would be one template with two declarations, with two incompatible defaults for the defaulted parameter).

580–581

I believe we can write this as

template<contiguous_iterator _It, class _EndOrSize>
    span(_It, _EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;

Note the name change to _EndOrSize, to match the working draft. (This also self-documents why it's not constrained as sentinel_for<_It>: it's because it's not necessarily an _End; it might be a _Size instead, e.g. an int.)

Ditto line 586: template<ranges::contiguous_range _Range>.

libcxx/test/std/containers/views/span.cons/iterator_iterator.fail.cpp

49–55

I'd prefer to see these as simple compile-time tests:

static_assert( std::is_constructible_v<std::span<int>, int*, int*>);
static_assert(!std::is_constructible_v<std::span<int>, const int*, const int*>);
static_assert(!std::is_constructible_v<std::span<int>, volatile int*, volatile int*>);
static_assert( std::is_constructible_v<std::span<const int>, int*, int*>);
static_assert( std::is_constructible_v<std::span<const int>, const int*, const int*>);
static_assert(!std::is_constructible_v<std::span<const int>, volatile int*, volatile int*>);
static_assert( std::is_constructible_v<std::span<volatile int>, int*, int*>);
static_assert(!std::is_constructible_v<std::span<volatile int>, const int*, const int*>);
static_assert( std::is_constructible_v<std::span<volatile int>, volatile int*, volatile int*>);

etc. And then similarly for std::is_convertible_v to test the non-explicit ctors.

I think it would be nice (but not necessary, and maybe excessively redundant) to put in some realistic tests that use span as a parameter-only type in the appropriate way:

void f1(std::span<int>) {}
void f2(std::span<const int>) {}
void fs1(std::span<int, 3>) {}
void fs2(std::span<const int, 3>) {}
int main() {
    std::vector<int> v = {1,2,3};
    f1(v);
    f2(v);
    f2(std::vector<int>{1,2,3});
    f1({v.data(), v.size()});
    f2({v.data(), v.size()});
    fs1(std::span{v.data(), v.size()});  // this works, right?
    fs2(std::span{v.data(), v.size()});  // this works, right?
}

and so on, just to touch all the relevant real-world use cases.

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

81–83

T val[2] = {};
auto s1 = std::span<T>(val, 2);
auto s2 = std::span<T, 2>(val, 2);
assert(s1.data() == &val[0] && s1.size() == 2);
assert(s2.data() == &val[0] && s2.size() == 2);
return true;

The big things here are that you can use assert in constexpr functions, and that you don't mark variables constexpr inside constexpr functions. I assumed that the const in const T was not significant to what you were trying to test; otherwise you could bring it back.
Probably you can collapse testConstexprSpan and testRuntimeSpan into the same function, now.

libcxx/test/std/containers/views/span.cons/range.fail.cpp

48–49 ↗

(On Diff #375116)

This is redundant with the primary template (thus DisabledBorrowedRange is redundant with IsARange). Did you mean to try with a type that enabled borrowed-range for itself? I'd suggest just using string_view for that.

59–61 ↗

(On Diff #375116)

No need to drag in all three of these; one will suffice. The relevant property is "being a range, but not being a contiguous range"... actually, waitaminute... these containers also are not borrowed ranges! So of course lines 59-61 won't compile, for a whole host of reasons. I don't think there's any reason to have lines 59-61 at all, now.

However, you might test a "borrowed but non-contiguous" rvalue range, and a "lvalue but non-contiguous" non-borrowed range. Again I recommend doing this as a compile-time static_assert, something like:

static_assert( std::is_constructible_v<std::span<int>, std::vector<int>&>);  // non-borrowed lvalue
static_assert(!std::is_constructible_v<std::span<int>, std::vector<int>&&>);  // non-borrowed rvalue
static_assert(!std::is_constructible_v<std::span<int>, std::deque<int>&>);  // non-contiguous lvalue
static_assert(!std::is_constructible_v<std::span<int>, std::subrange<std::deque<int>::iterator, std::deque<int>::iterator>&&>);  // non-contiguous borrowed rvalue

libcxx/test/std/containers/views/span.cons/simple_range.h

4 ↗

(On Diff #375116)

Once you convert range.fail.cpp to a bunch of static_asserts, you'll be using SimpleRange in only one file, and then it won't need its own header, so this comment will be moot.

If this class isn't scoped to a single test, then it should have a descriptive name like SimpleContiguousNonborrowedRange... which is just std::vector, isn't it? What's the point of making our own type here at all?

[jloser]

Address some review feedback:

• Add some #ifdef for ranges support in span
• s/__is_range_compatible/__is_span_compatible_range
• Simplify deduction guides to use concepts rather than enable_if_t
• Consistent SFINAE using = nullptr
• ADL proof to_address and distance
• Fix exposition with conditional explicitness on range constructor for span

[ldionne]

Thanks a lot for working on this!

I spoke with Joe on Discord and we agreed to make the change as-is, i.e. provide the constructors only when ranges are supported. That implies that compilers like AppleClang 12.0 (I think that's the only supported one) will NOT have the old span(Container&) constructors anymore, which is a breaking change. However, AppleClang 13.0 was released on September 20, which means that per our compiler support policy, we'd drop official support for 12.0. I'll get started on that but it does require upgrading Xcode on the CI nodes, and that's going to cause some problems for back-deployment testing. TL;DR: let's do as-if we didn't support 12.0 anymore and just mark the failing tests as XFAIL. I'll remove those XFAILs once we remove support for 12.0.

libcxx/include/span

195

This should be

#if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_RANGES)

That way, once we drop support for compilers that don't implement concepts, we'll just get rid of && !defined(_LIBCPP_HAS_NO_RANGES) entirely.

[jloser]

Try to fix #ifdef around ranges + concepts support assumptions
Make __is_span_compatible_range a concept
Convert most tests in iterator_iterator.fail.cpp into compile-time tests in iterator_iterator.compile.pass.cpp.

[jloser]

libcxx/include/span

196

Renamed to __is_span_compatible_range.

Talked with Louis on Discord and we decided we can assume ranges + concepts support. This will fail on CI for AppleClang 12.0 which we're dropping support for soon since AppleClang 13.0 just came out on 9/20. As such, made __is_span_compatible_range a concept which allows me to use terse syntax below in those constructors rather than enable_if_t<...>.

[jloser]

libcxx/include/span

195

I changed it to that, but keep in mind p1394 is C++20 and not C++23. So, what do you think about

#if defined(__cpp_lib_concepts) && !defined(_LIBCPP_HAS_NO_RANGES)

instead? This will ensure concepts supports and >= C++20.

[jloser]

• Simplify test functions in iterator_len.pass.cpp and iterator_iterator.pass.cpp since we can use assert in constexpr functions.
• Mark new tests as UNSUPPORTED: libcpp-has-no-incomplete-ranges

[jloser]

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

81–83

I like that much better -- thanks! Just applied your suggestion and collapsed the previous testConstexprSpan and testRuntimeSpan. Similarly in iterator_iterator.pass.cpp.

[jloser]

Simplify range.pass.cpp.

• TODO: convert check_cv to using std::is_constructible_v

[jloser]

libcxx/test/std/containers/views/span.cons/simple_range.h

4 ↗

(On Diff #375116)

Its new use in range.pass.cpp will be that we can have our test() function be usable in a constexpr context since std::vector isn't fully constexpr yet.

[• Quuxplusone]

libcxx/test/std/containers/views/span.cons/simple_range.h

4 ↗

(On Diff #375116)

Makes sense, but for that, you might be able to get away with either int[10] or std::array<int,10> or libcxx/test/support/test_constexpr_container.h (which right now is used only in the back_inserter tests IIRC).

[jloser]

Simplify tests from Arthur's feedback

[jloser]

Remove dead code from range.compile.pass.cpp

[jloser]

Remove reliance on SimpleRange from deduct.pass.cpp
Remove simple_range.h

[jloser]

libcxx/test/std/containers/views/span.cons/simple_range.h

4 ↗

(On Diff #375116)

Ended up not needing it in favor of our favorite friend the C-style array. Removed simple_range.h, etc.

[jloser]

libcxx/test/std/containers/views/span.cons/iterator_iterator.fail.cpp

49–55

I reworked several tests (itr/itr, itr/len, range) to mostly be compile-time tests that use std::is_constructible_v and std::is_convertible_v and I like that a lot better!

I did leave iterator_iterator.fail.cpp and iterator_len.fail.cpp which test the explicit constructors respectively. I don't see how we can use std::is_convertible_v since the constructor takes more than one parameter (two in each of these cases), but we only have one template type for the from type in std::is_convertible_v. Am I missing something?

As for the idea around adding tests that we can call a function taking a span parameter, I don't immediately see the value-add it has from a coverage perspective. I haven't added them now, but if you can convince me what coverage it adds, I'm happy to add them.

[jloser]

Remove extra scope in iterator_iterator.fail.cpp

[jloser]

Mark a few tests as UNSUPPORTED: libcpp-no-concepts
clang-format a few places

[jloser]

Collapse .compile.pass.cpp into their respective .pass.cpp files
Try to fix #ifdefs to make CI happy

[jloser]

Remove extra test in deduct.pass.cpp

[jloser]

Prefer test() over assert(test()) in a few tests

[jloser]

@ldionne @Quuxplusone can you help me understand why a few static_asserts fail on the CI job (https://reviews.llvm.org/harbormaster/unit/view/1268018/)? They pass locally just fine for me. Everything else modulo formatting was passing.

[• Quuxplusone]

In D110503#3030310, @jloser wrote:

@ldionne @Quuxplusone can you help me understand why a few static_asserts fail on the CI job (https://reviews.llvm.org/harbormaster/unit/view/1268018/)? They pass locally just fine for me. Everything else modulo formatting was passing.

Well, your new code in <span> is enabled only in language versions greater than 20, but your new test runs in versions greater than or equal to 20. Did you intend the test to also UNSUPPORTED: c++20? or did you intend the new code to be enabled when _LIBCPP_STD_VER > 17? (Is this a C++2b feature or a C++20 feature? I think it's C++20, but check me on that.)

libcxx/include/span

204

Nit: s/>> (/>>(/ for consistency with _ElementType(*)[].

235–256

Nit:

template <class _It,
          enable_if_t<contiguous_iterator<_It> &&
                      is_convertible_v<remove_reference_t<iter_reference_t<_It>>(*)[], element_type(*)[]>>* = nullptr>

(Cuddling > > (, and using enable_if_t<X>* = nullptr (note the *) instead of enable_if_t<X, nullptr_t> = nullptr.)

[• Quuxplusone]

libcxx/include/span

455–461

Scope-creep: It would be nice to refactor this SFINAE, for consistency, as

template <class _OtherElementType, size_t _OtherExtent,
          enable_if_t<is_convertible_v<_OtherElementType(*)[], element_type(*)[]>>* = nullptr>
_LIBCPP_INLINE_VISIBILITY
constexpr span(const span<_OtherElementType, _OtherExtent>& __other) noexcept
        : __data(__other.data()), __size(__other.size()) {}

and so on throughout this file. But I could submit a separate (subsequent) PR for this myself. (Heck, I could even underscore-suffix the data members __data and __size!)

[jloser]

Enable range constructor in C++20 mode, not > C++20 which should fix CI
Fix some clang-format mishaps with cuddling of >> vs > >.

[jloser]

In D110503#3030782, @Quuxplusone wrote:

In D110503#3030310, @jloser wrote:

@ldionne @Quuxplusone can you help me understand why a few static_asserts fail on the CI job (https://reviews.llvm.org/harbormaster/unit/view/1268018/)? They pass locally just fine for me. Everything else modulo formatting was passing.

Well, your new code in <span> is enabled only in language versions greater than 20, but your new test runs in versions greater than or equal to 20. Did you intend the test to also UNSUPPORTED: c++20? or did you intend the new code to be enabled when _LIBCPP_STD_VER > 17? (Is this a C++2b feature or a C++20 feature? I think it's C++20, but check me on that.)

Oops! It's intended to be a C++20 feature (that is, P1394 targets C++20 not C++23), and since std::span is C++20, we just need the #ifdef around ranges support. Just fixed that -- thanks!.

[jloser]

libcxx/include/span

455–461

I'd vote let's just do that consistently throughout this file in a follow-up PR if that's OK with you.

[ldionne]

I'm relying on Arthur's in-depth review of the tests. Ship it once my comments have been resolved, everybody else is happy and CI is passing. Thanks a lot!

libcxx/include/span

195

I had made my comment thinking this was a C++23 feature, but what you have right now (just #if !defined(_LIBCPP_HAS_NO_RANGES)) seems like the correct thing to me.

239

Here and elsewhere.

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

2

Here and throughout.

5

Let's also rename this test to iterator_len.verify.cpp, since it's a verify-style test.

Note that we support verify-style failures in .fail.cpp tests for historical reasons only and we should move away from doing that, hence my request.

[jloser]

Address Louis's feedback

[jloser]

Fix debug iterators CI build due to typo in _LIBCPP_ASSERT call

[jloser]

Sprinkle some #if !defined(_LIBCPP_HAS_NO_RANGES) to guard against not having iter_reference_t and friends

[jloser]

ping @Quuxplusone - what do you think of the tests now? I reworked a lot of them to be compile-time tests where possible.

[ldionne]

Note: Please wait until CI is back online and passing before shipping this. It would suck to come back Monday and have a bunch of failures to investigate :(

[jloser]

In D110503#3037449, @ldionne wrote:

Note: Please wait until CI is back online and passing before shipping this. It would suck to come back Monday and have a bunch of failures to investigate :(

No problem, I'm in no rush to land this. We'll wait until CI is back and passing and Arthur thinks the tests are in good shape before we ship it.

[• Quuxplusone]

Mostly nits, but "this helper trait is now completely unused" is significant enough that I think we'd benefit from one more round.

libcxx/include/span

70

s/extent/Extent/

179–183

Actually, isn't this type-trait completely unused now? Let's remove lines 172–194!

If I'm wrong and it is used somewhere, then please add a test for

struct Widget { friend int size(Widget*); };
static_assert(!std::is_constructible_v<std::span<Widget>, Widget(&)[]>);

and remove the , nullptr_t on lines 179 and 181.

196

Belatedly altering my advice a little, sorry: If this is a concept, especially if it's being used with the terse syntax, then let's call it __span_compatible_range (with no is_ prefix).
Also, line 201 has one bogus extra space.

433

• Parens-not-braces for initializations.
• Actually _VSTD::distance(__first, __last) is definitely wrong; please add some tests where the iterator and sentinel types are different. This should be simply __last - __first.

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

17

s/extent/Extent/g

34

s/tability/tibility/
and likewise in at least one other file

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

21 ↗

(On Diff #376256)

s/extent/Extent/
I'm beginning to suspect some automated process was responsible for lowercasing all of these Extents. :)

29 ↗

(On Diff #376256)

createImplicitSpan<int, 1>(arr, arr+1)... although, why 1, if the array has 3 elements? Perhaps createImplicitSpan<int, 3>(arr, arr+3) would get the point across better.

Btw, you could turn this into a SFINAE test and get rid of the .verify.cpp. The SFINAE test would look basically like https://godbolt.org/z/xf6sn8asf

template<class T, size_t Extent> bool f(int, std::span<T, Extent>) { return true; }
template<class, size_t> bool f(long, std::pair<int*, int*>) { return false; }

    int a[3] = {1,2,3};
    assert((f<int, std::dynamic_extent>(42, {a, a+3})));
    assert((!f<int, 3>(42, {a, a+3})));

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

24

s/rU/U/, although if you just killed this entire comment block, that'd also be fine with me, personally.

47–50

test_from_range should return void, and these lines shouldn't assert.

65–66

Also worth checking:

static_assert(!std::is_constructible_v<std::span<const int>, std::vector<int>>); // non-borrowed rvalue
static_assert(!std::is_constructible_v<std::span<const int, 3>, std::vector<int>>); // non-borrowed rvalue

Try to arrange the lines so that they repeat in the same pattern as much as possible. E.g. you could improve the pattern by switching lines 60-61 with lines 62-63.

70–71

I waffle on this, but I think it'll be better to use the random_access_iterator from test_iterators.h instead of depending on deque. Also, technically, we can leave off the trailing && because is_constructible is just going to re-apply && on its side, anyway. E.g.

static_assert(std::is_constructible_v<std::span<int>, std::ranges::subrange<contiguous_iterator<int*>>>);  // contiguous borrowed rvalue
static_assert(!std::is_constructible_v<std::span<int>, std::ranges::subrange<random_access_iterator<int*>>>);  // non-contiguous borrowed rvalue

[• Quuxplusone]

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

28 ↗

(On Diff #376256)

If you decide to keep a .verify.cpp test for span, then please add a test for

std::span<const int> sp = {0, 0};

Today we accept that (interpreting 0 as a null pointer constant); after this PR we should correctly reject it (as libstdc++ and MSVC already do).

[• Quuxplusone]

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

22

#include <iterator> for std::data and std::size.
Generally, check the output of

./bin/llvm-lit -sv --param std=c++2b --param cxx_under_test=`pwd`/bin/clang++ --param enable_modules=True ../libcxx/test/std/containers/views/

(notice --param enable_modules=True) and fix the things it complains about, both in <span> and in the tests. buildkite will also test this, in the "Modules" build step; but the above magic incantation will let you do it locally.

[jloser]

Address some of Arthur's feedback.

• Remove unused type trait in span
• Fix typos in a variety of places (e.g. s/extent/Extent, s/constructability/constructibility)
• Rename iterator_iterator.{pass,verify}.cpp to iterator_sentinel.{pass,verify}.cpp

[jloser]

libcxx/include/span

70

For consistency with our synopsis, I'll use Extent. But do note the standard uses extent in the synopsis. I don't like differing just for preference with the implementation of how we use Extent everywhere, but I like being locally consistent within a neighborhood of code.

179–183

It's unused and removed now. Good call!

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

28 ↗

(On Diff #376256)

Added said test and we properly reject it.

[jloser]

Address some of Arthur's feedback.

• test_from_range should return void - cleans up some asserts in callers
• Adjust tests a bit in range.pass.cpp to avoid dependency on deque
• Reoganize some tests for clarity in range.pass.cpp

[• Quuxplusone]

libcxx/include/span

70

Ah, yeah, I noticed the Standard's use of extent yesterday while working on https://quuxplusone.github.io/blog/2021/10/03/p2447-span-from-initializer-list/ . So it wasn't just a typo. I agree, I like consistency. But today I have no strong preference between the spellings: if we want to use extent consistently, or Extent consistently, I don't care.

255

This has the same problem as in the string_view PR: I don't think operator<= is always valid here. Please add a test for an iterator/sentinel pair that doesn't support <=.

The issue is not that __first <= __last might be false; the issue is that it might not be well-formed at all.

[jloser]

libcxx/include/span

255

The well-formedness is definitely a wrinkle. I'll add a test to expose this issue and remove the _LIBCPP_ASSERT.

Obviously, we could guard the _LIBCPP_ASSERT with requires to assure well-formedness of __first <= __last, but it's probably not worth it. I'd like to get some clarity in general on precondition checking in libc++ as I mentioned in the string_view PR. WDYT?

[jloser]

Rebase to trigger CI

[jloser]

Mark several other span tests as UNSUPPORTED: libcpp-has-no-incomplete-ranges

[jloser]

Mark empty.pass.cpp as UNSUPPORTED: libcpp-has-no-incomplete-ranges

[jloser]

XFAIL: AppleClang-12.0.0 a bunch of span tests.
Fix modules build for use of ranges::size in span

[jloser]

Add test for constructing span from iterator/sentinel
Add sized_sentinel_wrapper to "test_iterators.h"

[jloser]

[NFC] Spacing in sized_sentinel_wrapper's operator--

[ldionne]

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

12 ↗

(On Diff #377376)

It just occurred to me that if you wanted, you could also replace all those XFAIL: apple-clang-12.0.0 by XFAIL: libcpp-no-concepts. IDK why I didn't think of that sooner. Feel free to do it or not, those are both temporary things anyway.

[jloser]

Fix debug build

[jloser]

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

12 ↗

(On Diff #377376)

Eh, I'll leave it as is for now. I'm hoping it won't live very long as we talked about since we're dropping support for AppleClang 12.0.0 shortly.

[jloser]

@Quuxplusone @ldionne this PR should be ready with CI passing on this revision. Feel free to submit follow-up PRs for cleaning up other unrelated (from the purpose of this PR) constructor's SFINAE with nullptr, etc.

Appreciate the thorough review!

[jloser]

Rebase since D110718 landed

[ldionne]

LGTM, please wait a couple hours for Arthur to say "no" if he still has stuff to say, but otherwise ship it!

[ldionne]

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

32

I know this has been landed for a while, but in retrospect this test doesn't seem sufficient to me. I stumbled upon it doing something else and noticed. We are actually testing the array constructor of std::span, unless I am missing something.

Also, ideally, we would add a runtime test instead of each test below where we check that std::span is positively constructible from something.

@jloser Would you be interested in revisiting those? If not, I'll make a note to get to it eventually.

libcxx/docs/Status/Cxx20Papers.csv

 "`P1650 <https://wg21.link/P1650>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","",""
 "`P1651 <https://wg21.link/P1651>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","|Complete|","13.0"
 "`P1652 <https://wg21.link/P1652>`__","LWG","Printf corner cases in std::format","Cologne","",""
 "`P1661 <https://wg21.link/P1661>`__","LWG","Remove dedicated precalculated hash lookup interface","Cologne","|Nothing To Do|",""
 "`P1754 <https://wg21.link/P1754>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","|In Progress|",""
 "","","","","",""
 "`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","|Complete| [#note-P0883]_","13.0"
 "`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","* *",""
-"`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","* *",""
+"`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","|Complete|","14.0"
 "`P1456 <https://wg21.link/P1456>`__","LWG","Move-only views","Belfast","* *",""
 "`P1622 <https://wg21.link/P1622>`__","LWG","Mandating the Standard Library: Clause 32 - Thread support library","Belfast","* *",""
 "`P1645 <https://wg21.link/P1645>`__","LWG","constexpr for numeric algorithms","Belfast","|Complete|","12.0"
 "`P1664 <https://wg21.link/P1664>`__","LWG","reconstructible_range - a concept for putting ranges back together","Belfast","* *",""
 "`P1686 <https://wg21.link/P1686>`__","LWG","Mandating the Standard Library: Clause 27 - Time library","Belfast","* *",""
 "`P1690 <https://wg21.link/P1690>`__","LWG","Refinement Proposal for P0919 Heterogeneous lookup for unordered containers","Belfast","|Complete|","12.0"
 "`P1716 <https://wg21.link/P1716>`__","LWG","ranges compare algorithm are over-constrained","Belfast","* *",""
 "`P1718 <https://wg21.link/P1718>`__","LWG","Mandating the Standard Library: Clause 25 - Algorithms library","Belfast","* *",""

libcxx/include/span

public:
     using reference = element_type&;
     using const_reference = const element_type&;
     using iterator = implementation-defined;
     using reverse_iterator = std::reverse_iterator<iterator>;
     static constexpr size_type extent = Extent;
 
     // [span.cons], span constructors, copy, assignment, and destructor
     constexpr span() noexcept;
-    constexpr explicit(Extent != dynamic_extent) span(pointer ptr, size_type count);
-    constexpr explicit(Extent != dynamic_extent) span(pointer firstElem, pointer lastElem);
+    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;
     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 Container>
-        constexpr explicit(Extent != dynamic_extent) span(Container& cont);
-    template <class Container>
-        constexpr explicit(Extent != dynamic_extent) span(const Container& cont);
+    template<class R>
+      constexpr explicit(extent != dynamic_extent) span(R&& r);
     constexpr span(const span& other) noexcept = default;
     template <class OtherElementType, size_t OtherExtent>
         constexpr explicit(Extent != dynamic_extent) span(const span<OtherElementType, OtherExtent>& s) noexcept;
     ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
 
     // [span.sub], span subviews
     template <size_t Count>
         constexpr span<element_type, Count> first() const;
public:
     constexpr reverse_iterator rbegin() const noexcept;
     constexpr reverse_iterator rend() const noexcept;
 
 private:
     pointer data_;    // exposition only
     size_type size_;  // exposition only
 };
 
+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>;
 
 template<class T, size_t N>
     span(array<T, N>&) -> span<T, N>;
 
 template<class T, size_t N>
     span(const array<T, N>&) -> span<const T, N>;
 
-template<class Container>
-    span(Container&) -> span<typename Container::value_type>;
-
-template<class Container>
-    span(const Container&) -> span<const typename Container::value_type>;
+template<class R>
+    span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
 
 } // namespace std
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__iterator/concepts.h>
 #include <__iterator/wrap_iter.h>
+#include <__ranges/concepts.h>
+#include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <array>        // for array
 #include <cstddef>      // for byte
 #include <iterator>     // for iterators
 #include <limits>
 #include <type_traits>  // for remove_cv, etc
 #include <version>

 
 #if _LIBCPP_STD_VER > 17
 
 inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
 template <typename _Tp, size_t _Extent = dynamic_extent> class span;
 
 
 template <class _Tp>
-struct __is_span_impl : public false_type {};
-
-template <class _Tp, size_t _Extent>
-struct __is_span_impl<span<_Tp, _Extent>> : public true_type {};
+struct __is_std_array : false_type {};
 
-template <class _Tp>
-struct __is_span : public __is_span_impl<remove_cv_t<_Tp>> {};
+template <class _Tp, size_t _Sz>
+struct __is_std_array<array<_Tp, _Sz>> : true_type {};
 
 template <class _Tp>
-struct __is_std_array_impl : public false_type {};
+struct __is_std_span : false_type {};
 
 template <class _Tp, size_t _Sz>
-struct __is_std_array_impl<array<_Tp, _Sz>> : public true_type {};
-
-template <class _Tp>
-struct __is_std_array : public __is_std_array_impl<remove_cv_t<_Tp>> {};
+struct __is_std_span<span<_Tp, _Sz>> : true_type {};
 
 template <class _Tp, class _ElementType, class = void>
 struct __is_span_compatible_container : public false_type {};
 
 template <class _Tp, class _ElementType>
 struct __is_span_compatible_container<_Tp, _ElementType,
         void_t<
         // is not a specialization of span
-            enable_if_t<!__is_span<_Tp>::value, nullptr_t>,
+            enable_if_t<!__is_std_span<remove_cvref_t<_Tp>>::value, nullptr_t>,
         // is not a specialization of array
-            enable_if_t<!__is_std_array<_Tp>::value, nullptr_t>,
+            enable_if_t<!__is_std_array<remove_cvref_t<_Tp>>::value, nullptr_t>,
         // is_array_v<Container> is false,
             enable_if_t<!is_array_v<_Tp>, nullptr_t>,
         // data(cont) and size(cont) are well formed
             decltype(data(declval<_Tp>())),
             decltype(size(declval<_Tp>())),
         // remove_pointer_t<decltype(data(cont))>(*)[] is convertible to ElementType(*)[]
             enable_if_t<
                 is_convertible_v<remove_pointer_t<decltype(data(declval<_Tp &>()))>(*)[],
                                  _ElementType(*)[]>,
                 nullptr_t>
         >>
     : public true_type {};
 
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+template <class _Range, class _ElementType>
+concept __is_span_compatible_range =
+  ranges::contiguous_range<_Range> &&
+  ranges::sized_range<_Range> &&
+  (ranges::borrowed_range<_Range> || is_const_v<_ElementType>) &&
+  !__is_std_span<remove_cvref_t<_Range>>::value  &&
+  !__is_std_array<remove_cvref_t<_Range>>::value &&
+  !is_array_v<remove_cvref_t<_Range>> &&
+  is_convertible_v<remove_reference_t<ranges::range_reference_t<_Range>> (*)[], _ElementType(*)[]>;
+#endif
 
 template <typename _Tp, size_t _Extent>
 class _LIBCPP_TEMPLATE_VIS span {
 public:
 //  constants and types
     using element_type           = _Tp;
     using value_type             = remove_cv_t<_Tp>;
     using size_type              = size_t;

 
 // [span.cons], span constructors, copy, assignment, and destructor
     template <size_t _Sz = _Extent, enable_if_t<_Sz == 0, nullptr_t> = nullptr>
     _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr} {}
 
     constexpr span           (const span&) noexcept = default;
     constexpr span& operator=(const span&) noexcept = default;
 
-    _LIBCPP_INLINE_VISIBILITY constexpr explicit span(pointer __ptr, size_type __count) : __data{__ptr}
-        { (void)__count; _LIBCPP_ASSERT(_Extent == __count, "size mismatch in span's constructor (ptr, len)"); }
-    _LIBCPP_INLINE_VISIBILITY constexpr explicit span(pointer __f, pointer __l) : __data{__f}
-        { (void)__l;     _LIBCPP_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)"); }
+    template <class _It,
+              enable_if_t<contiguous_iterator<_It> &&
+                              is_convertible_v<remove_reference_t<iter_reference_t<_It> > (*)[], element_type (*)[]>,
+                          nullptr_t> = nullptr>
+    _LIBCPP_INLINE_VISIBILITY constexpr explicit span(_It __first, size_type __count)
+        : __data{_VSTD::to_address(__first)} {
+      (void)__count;
+      _LIBCPP_ASSERT(_Extent == __count, "size mismatch in span's constructor (iterator, len)");
+    }
+
+    template <
+        class _It, class _End,
+        enable_if_t<is_convertible_v<remove_reference_t<iter_reference_t<_It> > (*)[], element_type (*)[]> &&
+                        contiguous_iterator<_It> && sized_sentinel_for<_End, _It> && !is_convertible_v<_End, size_t>,
+                    nullptr_t> = nullptr>
+    _LIBCPP_INLINE_VISIBILITY constexpr explicit span(_It __first, _End __last) : __data{_VSTD::to_address(__first)} {
+      (void)__last;
+      _LIBCPP_ASSERT(__first <= __last, "invalid range in span's constructor (iterator, sentinel)");
+      _LIBCPP_ASSERT(last - first == _Extent,
+                     "invalid range in span's constructor (iterator sentinel): last - first != extent");
+    }
 
     _LIBCPP_INLINE_VISIBILITY constexpr span(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>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(const array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}
 
-    template <class _Container>
-    _LIBCPP_INLINE_VISIBILITY
-        constexpr explicit 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 (range)");
-        }
-
-    template <class _Container>
-    _LIBCPP_INLINE_VISIBILITY
-        constexpr explicit 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 (range)");
-        }
+#if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_RANGES)
+    template <__is_span_compatible_range<element_type> _Range>
+    _LIBCPP_INLINE_VISIBILITY constexpr explicit span(_Range&& __r) : __data{ranges::data(__r)} {
+      _LIBCPP_ASSERT(ranges::size(__r) == _Extent, "size mismatch in span's constructor (range)");
+#endif
 
     template <class _OtherElementType>
     _LIBCPP_INLINE_VISIBILITY
         constexpr span(const span<_OtherElementType, _Extent>& __other,
                        enable_if_t<
                           is_convertible_v<_OtherElementType(*)[], element_type (*)[]>,
                           nullptr_t> = nullptr)
         : __data{__other.data()} {}
#endif
     static constexpr size_type extent = dynamic_extent;
 
 // [span.cons], span constructors, copy, assignment, and destructor
     _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}, __size{0} {}
 
     constexpr span           (const span&) noexcept = default;
     constexpr span& operator=(const span&) noexcept = default;
 
-    _LIBCPP_INLINE_VISIBILITY constexpr span(pointer __ptr, size_type __count) : __data{__ptr}, __size{__count} {}
-    _LIBCPP_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}, __size{static_cast<size_t>(distance(__f, __l))} {}
+    template <class _It,
+              enable_if_t<contiguous_iterator<_It> &&
+                              is_convertible_v<remove_reference_t<iter_reference_t<_It> > (*)[], element_type (*)[]>,
+                          nullptr_t> = nullptr>
+    _LIBCPP_INLINE_VISIBILITY constexpr span(_It __first, size_type __count)
+        : __data{_VSTD::to_address(__first)}, __size{__count} {}
+
+    template <
+        class _It, class _End,
+        enable_if_t<is_convertible_v<remove_reference_t<iter_reference_t<_It> > (*)[], element_type (*)[]> &&
+                        contiguous_iterator<_It> && sized_sentinel_for<_End, _It> && !is_convertible_v<_End, size_t>,
+                    nullptr_t> = nullptr>
+    _LIBCPP_INLINE_VISIBILITY constexpr span(_It __first, _End __last)
+        : __data{_VSTD::to_address(__first)}, __size(static_cast<size_t>(_VSTD::distance(__first, __last))) {}
 
     template <size_t _Sz>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(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>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(const array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
 
-    template <class _Container>
-    _LIBCPP_INLINE_VISIBILITY
-        constexpr span(      _Container& __c,
-            enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr)
-        : __data{_VSTD::data(__c)}, __size{(size_type) _VSTD::size(__c)} {}
-
-    template <class _Container>
-    _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)}, __size{(size_type) _VSTD::size(__c)} {}
-
+#  if !defined(_LIBCPP_HAS_NO_RANGES)
+    template <__is_span_compatible_range<element_type> _Range>
+    _LIBCPP_INLINE_VISIBILITY constexpr span(_Range&& __r) : __data{ranges::data(__r)}, __size{ranges::size(__r)} {}
+#  endif
 
     template <class _OtherElementType, size_t _OtherExtent>
     _LIBCPP_INLINE_VISIBILITY
         constexpr span(const span<_OtherElementType, _OtherExtent>& __other,
                        enable_if_t<
                           is_convertible_v<_OtherElementType(*)[], element_type (*)[]>,
                           nullptr_t> = nullptr) noexcept
         : __data{__other.data()}, __size{__other.size()} {}
 
 //    ~span() noexcept = default;
 
     template <size_t _Count>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span<element_type, _Count> first() const noexcept
     {
         _LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::first()");

 
 template <class _Tp, size_t _Extent>
 _LIBCPP_INLINE_VISIBILITY
 auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept
 -> enable_if_t<!is_const_v<_Tp>, decltype(__s.__as_writable_bytes())>
 { return __s.__as_writable_bytes(); }
 
 //  Deduction guides
+template<contiguous_iterator _It, class _EndOrSize>
+    span(_It, _EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;
+
 template<class _Tp, size_t _Sz>
     span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;
 
 template<class _Tp, size_t _Sz>
     span(array<_Tp, _Sz>&) -> span<_Tp, _Sz>;
 
 template<class _Tp, size_t _Sz>
     span(const array<_Tp, _Sz>&) -> span<const _Tp, _Sz>;
 
-template<class _Container>
-    span(_Container&) -> span<typename _Container::value_type>;
-
-template<class _Container>
-    span(const _Container&) -> span<const typename _Container::value_type>;
+#  if !defined(_LIBCPP_HAS_NO_RANGES)
+template<ranges::contiguous_range _Range>
+    span(_Range&&) -> span<remove_reference_t<ranges::range_reference_t<_Range>>>;
+#endif
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_SPAN

libcxx/test/std/containers/views/span.cons/container.fail.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++03, c++11, c++14, c++17
-
-// <span>
-
-//  template<class Container>
-//     constexpr span(Container& cont);
-//   template<class Container>
-//     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,
-//   — data(cont) and size(cont) are both well-formed, and
-//   — remove_pointer_t<decltype(data(cont))>(*)[] is convertible to ElementType(*)[].
-//
-
-#include <span>
-#include <cassert>
-#include <deque>
-#include <forward_list>
-#include <list>
-#include <vector>
-
-#include "test_macros.h"
-
-//  Look ma - I'm a container!
-template <typename T>
-struct IsAContainer {
-    constexpr IsAContainer() : v_{} {}
-    constexpr size_t size() const {return 1;}
-    constexpr       T *data() {return &v_;}
-    constexpr const T *data() const {return &v_;}
-
-    constexpr const T *getV() const {return &v_;} // for checking
-    T v_;
-};
-
-template <typename T>
-struct NotAContainerNoData {
-    size_t size() const {return 0;}
-};
-
-template <typename T>
-struct NotAContainerNoSize {
-    const T *data() const {return nullptr;}
-};
-
-template <typename T>
-struct NotAContainerPrivate {
-private:
-    size_t size() const {return 0;}
-    const T *data() const {return nullptr;}
-};
-
-template<class T, size_t extent, class container>
-std::span<T, extent> createImplicitSpan(container c) {
-    return {c}; // expected-error {{chosen constructor is explicit in copy-initialization}}
-}
-
-int main(int, char**)
-{
-
-//  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>    s3{std::vector<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    }
-
-//  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>    s3{NotAContainerNoSize<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const int>    s5{NotAContainerPrivate<int>()};  // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-
-//  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>    s13{std::list<int>()};            // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const int>    s15{std::forward_list<int>()};    // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    }
-
-//  Not the same type
-    {
-    IsAContainer<int> c;
-    std::span<float>    s1{c};   // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
-    }
-
-//  CV wrong
-    {
-    IsAContainer<const          int> c;
-    IsAContainer<const volatile int> cv;
-    IsAContainer<      volatile int> v;
-
-    std::span<               int> s1{c};    // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s2{v};    // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s3{cv};   // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<const          int> s4{v};    // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const          int> s5{cv};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<      volatile int> s6{c};    // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    std::span<      volatile int> s7{cv};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    }
-
-// explicit constructor necessary
-    {
-    IsAContainer<int> c;
-    const IsAContainer<int> cc;
-
-    createImplicitSpan<int, 1>(c);
-    createImplicitSpan<int, 1>(cc);
-    }
-
-  return 0;
-}

libcxx/test/std/containers/views/span.cons/container.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++03, c++11, c++14, c++17
-
-// <span>
-
-//  template<class Container>
-//     constexpr span(Container& cont);
-//   template<class Container>
-//     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,
-//   — data(cont) and size(cont) are both well-formed, and
-//   — remove_pointer_t<decltype(data(cont))>(*)[] is convertible to ElementType(*)[].
-//
-
-
-#include <span>
-#include <cassert>
-#include <string>
-#include <vector>
-
-#include "test_macros.h"
-
-//  Look ma - I'm a container!
-template <typename T>
-struct IsAContainer {
-    constexpr IsAContainer() : v_{} {}
-    constexpr size_t size() const {return 1;}
-    constexpr       T *data() {return &v_;}
-    constexpr const T *data() const {return &v_;}
-    constexpr       T *begin() {return &v_;}
-    constexpr const T *begin() const {return &v_;}
-    constexpr       T *end() {return &v_ + 1;}
-    constexpr const T *end() const {return &v_ + 1;}
-
-    constexpr T const *getV() const {return &v_;} // for checking
-    T v_;
-};
-
-
-void checkCV()
-{
-    std::vector<int> v  = {1,2,3};
-
-//  Types the same
-    {
-    std::span<               int> s1{v};    // a span<               int> pointing at int.
-    }
-
-//  types different
-    {
-    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.
-    }
-
-//  Constructing a const view from a temporary
-    {
-    std::span<const int>    s1{IsAContainer<int>()};
-    std::span<const int>    s3{std::vector<int>()};
-    (void) s1;
-    (void) s3;
-    }
-}
-
-
-template <typename T>
-constexpr bool testConstexprSpan()
-{
-    constexpr IsAContainer<const T> val{};
-    std::span<const T> s1{val};
-    return s1.data() == val.getV() && s1.size() == 1;
-}
-
-template <typename T>
-constexpr bool testConstexprSpanStatic()
-{
-    constexpr IsAContainer<const T> val{};
-    std::span<const T, 1> s1{val};
-    return s1.data() == val.getV() && s1.size() == 1;
-}
-
-template <typename T>
-void testRuntimeSpan()
-{
-    IsAContainer<T> val{};
-    const IsAContainer<T> cVal;
-    std::span<T>       s1{val};
-    std::span<const T> s2{cVal};
-    assert(s1.data() == val.getV()  && s1.size() == 1);
-    assert(s2.data() == cVal.getV() && s2.size() == 1);
-}
-
-template <typename T>
-void testRuntimeSpanStatic()
-{
-    IsAContainer<T> val{};
-    const IsAContainer<T> cVal;
-    std::span<T, 1>       s1{val};
-    std::span<const T, 1> s2{cVal};
-    assert(s1.data() == val.getV()  && s1.size() == 1);
-    assert(s2.data() == cVal.getV() && s2.size() == 1);
-}
-
-struct A{};
-
-int main(int, char**)
-{
-    static_assert(testConstexprSpan<int>(),    "");
-    static_assert(testConstexprSpan<long>(),   "");
-    static_assert(testConstexprSpan<double>(), "");
-    static_assert(testConstexprSpan<A>(),      "");
-
-    static_assert(testConstexprSpanStatic<int>(),    "");
-    static_assert(testConstexprSpanStatic<long>(),   "");
-    static_assert(testConstexprSpanStatic<double>(), "");
-    static_assert(testConstexprSpanStatic<A>(),      "");
-
-    testRuntimeSpan<int>();
-    testRuntimeSpan<long>();
-    testRuntimeSpan<double>();
-    testRuntimeSpan<std::string>();
-    testRuntimeSpan<A>();
-
-    testRuntimeSpanStatic<int>();
-    testRuntimeSpanStatic<long>();
-    testRuntimeSpanStatic<double>();
-    testRuntimeSpanStatic<std::string>();
-    testRuntimeSpanStatic<A>();
-
-    checkCV();
-
-  return 0;
-}

libcxx/test/std/containers/views/span.cons/deduct.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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // <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>;
 //
 //   template<class T, size_t N>
 //     span(array<T, N>&) -> span<T, N>;
 //
 //   template<class T, size_t N>
 //     span(const array<T, N>&) -> span<const T, N>;
 //
-//   template<class Container>
-//     span(Container&) -> span<typename Container::value_type>;
-//
-//   template<class Container>
-//     span(const Container&) -> span<const typename Container::value_type>;
-
+//   template<class R>
+//     span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
 
 
 #include <span>
 #include <array>
 #include <cassert>
 #include <memory>
 #include <string>
 
 #include "test_macros.h"
 
-int main(int, char**)
+void test_iterator_sentinel() {
+  int arr[] = {1, 2, 3};
   {
+  std::span s{std::begin(arr), std::end(arr)};
+  ASSERT_SAME_TYPE(decltype(s), std::span<int>);
+  assert(s.size() == std::size(arr));
+  assert(s.data() == std::data(arr));
+  }
+  {
+  std::span s{std::begin(arr), 3};
+  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};
+    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>);
     assert(s.size() == std::size(arr));
     assert(s.data() == std::data(arr));
     }
+}
 
+void test_std_array() {
     {
     std::array<double, 4> arr = {1.0, 2.0, 3.0, 4.0};
     std::span s{arr};
     ASSERT_SAME_TYPE(decltype(s), std::span<double, 4>);
     assert(s.size() == arr.size());
     assert(s.data() == arr.data());
     }
 
     {
     const std::array<long, 5> arr = {4, 5, 6, 7, 8};
     std::span s{arr};
     ASSERT_SAME_TYPE(decltype(s), std::span<const long, 5>);
     assert(s.size() == arr.size());
     assert(s.data() == arr.data());
     }
+}
 
+void test_range_std_container() {
     {
     std::string str{"ABCDE"};
     std::span s{str};
     ASSERT_SAME_TYPE(decltype(s), std::span<char>);
     assert(s.size() == str.size());
     assert(s.data() == str.data());
     }
 
     {
     const std::string str{"QWERTYUIOP"};
     std::span s{str};
     ASSERT_SAME_TYPE(decltype(s), std::span<const char>);
     assert(s.size() == str.size());
     assert(s.data() == str.data());
     }
+}
+
+int main(int, char**)
+{
+  test_iterator_sentinel();
+  test_c_array();
+  test_std_array();
+  test_range_std_container();
 
   return 0;
 }

libcxx/test/std/containers/views/span.cons/iterator_iterator.fail.cpp

+//===------------------------------ 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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <span>
+
+// template <class It, class End>
+// constexpr explicit(Extent != dynamic_extent) span(It first, End last);
+// Requires: [first, last) shall be a valid range.
+//   If extent is not equal to dynamic_extent, then last - first shall be equal to extent.
+//
+
+#include <span>
+
+template<class T, size_t extent>
+std::span<T, extent> createImplicitSpan(T* first, T* last) {
+    return {first, last}; // expected-error {{chosen constructor is explicit in copy-initialization}}
+}
+
+int main(int, char**) {
+  // explicit constructor necessary
+  int arr[] = {1, 2, 3};
+  createImplicitSpan<int, 1>(std::begin(arr), std::next(std::begin(arr)));
+
+  return 0;
+}

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

+//===------------------------------ 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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <span>
+
+// template <class It, class End>
+// constexpr explicit(Extent != dynamic_extent) span(It first, End last);
+// Requires: [first, last) shall be a valid range.
+//   If extent is not equal to dynamic_extent, then last - first shall be equal to extent.
+//
+
+#include <span>
+#include <cassert>
+
+template <class T>
+constexpr bool test_ctor() {
+  T val[2] = {};
+  auto s1 = std::span<T>(std::begin(val), std::end(val));
+  auto s2 = std::span<T, 2>(std::begin(val), std::end(val));
+  assert(s1.data() == std::data(val) && s1.size() == std::size(val));
+  assert(s2.data() == std::data(val) && s2.size() == std::size(val));
+  return true;
+}
+
+template <size_t Extent>
+constexpr void test_constructability() {
+  static_assert(std::is_constructible_v<std::span<int, Extent>, int*, int*>);
+  static_assert(!std::is_constructible_v<std::span<int, Extent>, const int*, const int*>);
+  static_assert(!std::is_constructible_v<std::span<int, Extent>, volatile int*, volatile int*>);
+  static_assert(std::is_constructible_v<std::span<const int, Extent>, int*, int*>);
+  static_assert(std::is_constructible_v<std::span<const int, Extent>, const int*, const int*>);
+  static_assert(!std::is_constructible_v<std::span<const int, Extent>, volatile int*, volatile int*>);
+  static_assert(std::is_constructible_v<std::span<volatile int, Extent>, int*, int*>);
+  static_assert(!std::is_constructible_v<std::span<volatile int, Extent>, const int*, const int*>);
+  static_assert(std::is_constructible_v<std::span<volatile int, Extent>, volatile int*, volatile int*>);
+  static_assert(!std::is_constructible_v<std::span<int, Extent>, int*, float*>); // types wrong
+}
+
+constexpr bool test() {
+  test_constructability<std::dynamic_extent>();
+  test_constructability<3>();
+  struct A {};
+  assert(test_ctor<int>());
+  assert(test_ctor<A>());
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test());
+  assert(test());
+
+  return 0;
+}

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

+//===------------------------------ 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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <span>
+
+// template <class It>
+// constexpr explicit(Extent != dynamic_extent) span(It first, size_type count);
+//  If extent is not equal to dynamic_extent, then count shall be equal to extent.
+//
+
+#include <span>
+
+template <class T, size_t extent>
+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, 1);
+
+  return 0;
+}

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

+//===------------------------------ 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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <span>
+
+// template <class It>
+// constexpr explicit(Extent != dynamic_extent) span(It first, size_type count);
+//  If extent is not equal to dynamic_extent, then count shall be equal to extent.
+//
+
+
+#include <span>
+#include <cassert>
+#include <type_traits>
+
+template <size_t Extent>
+constexpr void test_constructability() {
+  struct Other {};
+  static_assert(std::is_constructible_v<std::span<int, Extent>, int*, size_t>);
+  static_assert(!std::is_constructible_v<std::span<int, Extent>, const int*, size_t>);
+  static_assert(std::is_constructible_v<std::span<const int, Extent>, int*, size_t>);
+  static_assert(std::is_constructible_v<std::span<const int, Extent>, const int*, size_t>);
+  static_assert(!std::is_constructible_v<std::span<int, Extent>, volatile int*, size_t>);
+  static_assert(!std::is_constructible_v<std::span<int, Extent>, const volatile int*, size_t>);
+  static_assert(!std::is_constructible_v<std::span<const int, Extent>, volatile int*, size_t>);
+  static_assert(!std::is_constructible_v<std::span<const int, Extent>, const volatile int*, size_t>);
+  static_assert(!std::is_constructible_v<std::span<volatile int, Extent>, const int*, size_t>);
+  static_assert(!std::is_constructible_v<std::span<volatile int, Extent>, const volatile int*, size_t>);
+  static_assert(
+      !std::is_constructible_v<std::span<int, Extent>, double*, size_t>); // iterator type differs from span type
+  static_assert(!std::is_constructible_v<std::span<int, Extent>, size_t, size_t>);
+  static_assert(!std::is_constructible_v<std::span<int, Extent>, Other*, size_t>); // unrelated iterator type
+}
+
+template <class T>
+constexpr bool test_ctor() {
+  T val[2] = {};
+  auto s1 = std::span<T>(val, 2);
+  auto s2 = std::span<T, 2>(val, 2);
+  assert(s1.data() == std::data(val) && s1.size() == std::size(val));
+  assert(s2.data() == std::data(val) && s2.size() == std::size(val));
+  return true;
+}
+
+constexpr bool test() {
+  test_constructability<std::dynamic_extent>();
+  test_constructability<3>();
+
+  struct A {};
+  test_ctor<int>();
+  test_ctor<A>();
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/containers/views/span.cons/ptr_len.fail.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++03, c++11, c++14, c++17
-
-// <span>
-
-// constexpr span(pointer ptr, size_type count);
-// Requires: [ptr, ptr + count) shall be a valid range.
-//  If extent is not equal to dynamic_extent, then count shall be equal to extent.
-//
-
-#include <span>
-#include <cassert>
-#include <string>
-
-#include "test_macros.h"
-
-
-               int   arr[] = {1,2,3};
-const          int  carr[] = {4,5,6};
-      volatile int  varr[] = {7,8,9};
-const volatile int cvarr[] = {1,3,5};
-
-template<class T, size_t extent>
-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**)
-{
-//  We can't check that the size doesn't match - because that's a runtime property
-//  std::span<int, 2>   s1(arr, 3);
-
-//  Type wrong
-    {
-    std::span<float>    s1(arr, 3);   // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
-    std::span<float, 3> s2(arr, 3);   // expected-error {{no matching constructor for initialization of 'std::span<float, 3>'}}
-    }
-
-//  CV wrong (dynamically sized)
-    {
-    std::span<               int> s1{ carr, 3}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s2{ varr, 3}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s3{cvarr, 3}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<const          int> s4{ varr, 3}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const          int> s5{cvarr, 3}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<      volatile int> s6{ carr, 3}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    std::span<      volatile int> s7{cvarr, 3}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    }
-
-//  CV wrong (statically sized)
-    {
-    std::span<               int,3> s1{ carr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<               int,3> s2{ varr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<               int,3> s3{cvarr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<const          int,3> s4{ varr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<const int, 3>'}}
-    std::span<const          int,3> s5{cvarr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<const int, 3>'}}
-    std::span<      volatile int,3> s6{ carr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
-    std::span<      volatile int,3> s7{cvarr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
-    }
-
-// explicit constructor necessary
-    {
-    createImplicitSpan<int, 1>(arr, 1);
-    }
-
-  return 0;
-}

libcxx/test/std/containers/views/span.cons/ptr_len.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++03, c++11, c++14, c++17
-
-// <span>
-
-// constexpr span(pointer ptr, size_type count);
-// Requires: [ptr, ptr + count) shall be a valid range.
-//  If extent is not equal to dynamic_extent, then count shall be equal to extent.
-//
-
-#include <span>
-#include <cassert>
-#include <string>
-
-#include "test_macros.h"
-
-void checkCV()
-{
-                   int   arr[] = {1,2,3};
-    const          int  carr[] = {4,5,6};
-          volatile int  varr[] = {7,8,9};
-    const volatile int cvarr[] = {1,3,5};
-
-//  Types the same (dynamic sized)
-    {
-    std::span<               int> s1{  arr, 3}; // a span<               int> pointing at int.
-    std::span<const          int> s2{ carr, 3}; // a span<const          int> pointing at const int.
-    std::span<      volatile int> s3{ varr, 3}; // a span<      volatile int> pointing at volatile int.
-    std::span<const volatile int> s4{cvarr, 3}; // a span<const volatile int> pointing at const volatile int.
-    assert(s1.size() + s2.size() + s3.size() + s4.size() == 12);
-    }
-
-//  Types the same (static sized)
-    {
-    std::span<               int,3> s1{  arr, 3};   // a span<               int> pointing at int.
-    std::span<const          int,3> s2{ carr, 3};   // a span<const          int> pointing at const int.
-    std::span<      volatile int,3> s3{ varr, 3};   // a span<      volatile int> pointing at volatile int.
-    std::span<const volatile int,3> s4{cvarr, 3};   // a span<const volatile int> pointing at const volatile int.
-    assert(s1.size() + s2.size() + s3.size() + s4.size() == 12);
-    }
-
-
-//  types different (dynamic sized)
-    {
-    std::span<const          int> s1{ arr, 3};      // a span<const          int> pointing at int.
-    std::span<      volatile int> s2{ arr, 3};      // a span<      volatile int> pointing at int.
-    std::span<      volatile int> s3{ arr, 3};      // a span<      volatile int> pointing at const int.
-    std::span<const volatile int> s4{ arr, 3};      // a span<const volatile int> pointing at int.
-    std::span<const volatile int> s5{carr, 3};      // a span<const volatile int> pointing at const int.
-    std::span<const volatile int> s6{varr, 3};      // a span<const volatile int> pointing at volatile int.
-    assert(s1.size() + s2.size() + s3.size() + s4.size() + s5.size() + s6.size() == 18);
-    }
-
-//  types different (static sized)
-    {
-    std::span<const          int,3> s1{ arr, 3};    // a span<const          int> pointing at int.
-    std::span<      volatile int,3> s2{ arr, 3};    // a span<      volatile int> pointing at int.
-    std::span<      volatile int,3> s3{ arr, 3};    // a span<      volatile int> pointing at const int.
-    std::span<const volatile int,3> s4{ arr, 3};    // a span<const volatile int> pointing at int.
-    std::span<const volatile int,3> s5{carr, 3};    // a span<const volatile int> pointing at const int.
-    std::span<const volatile int,3> s6{varr, 3};    // 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()
-{
-    constexpr T val[2] = {};
-    std::span<const T>   s1{val, 2};
-    std::span<const T,2> s2{val, 2};
-    return
-        s1.data() == &val[0] && s1.size() == 2
-    &&  s2.data() == &val[0] && s2.size() == 2;
-}
-
-
-template <typename T>
-void testRuntimeSpan()
-{
-    T val[2] = {};
-    std::span<T>   s1{val, 2};
-    std::span<T,2> s2{val, 2};
-    assert(s1.data() == &val[0] && s1.size() == 2);
-    assert(s2.data() == &val[0] && s2.size() == 2);
-}
-
-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>();
-
-    checkCV();
-
-  return 0;
-}

libcxx/test/std/containers/views/span.cons/ptr_ptr.fail.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++03, c++11, c++14, c++17
-
-// <span>
-
-// constexpr span(pointer first, pointer last);
-// Requires: [first, last) shall be a valid range.
-//   If extent is not equal to dynamic_extent, then last - first shall be equal to extent.
-//
-
-#include <span>
-#include <cassert>
-#include <string>
-
-#include "test_macros.h"
-
-
-               int   arr[] = {1,2,3};
-const          int  carr[] = {4,5,6};
-      volatile int  varr[] = {7,8,9};
-const volatile int cvarr[] = {1,3,5};
-
-template<class T, size_t extent>
-std::span<T, extent> createImplicitSpan(T* first, T* last) {
-    return {first, last}; // expected-error {{chosen constructor is explicit in copy-initialization}}
-}
-
-int main(int, char**)
-{
-//  We can't check that the size doesn't match - because that's a runtime property
-//  std::span<int, 2>   s1(arr, arr + 3);
-
-//  Type wrong
-    {
-    std::span<float>    s1(arr, arr + 3);   // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
-    std::span<float, 3> s2(arr, arr + 3);   // expected-error {{no matching constructor for initialization of 'std::span<float, 3>'}}
-    }
-
-//  CV wrong (dynamically sized)
-    {
-    std::span<               int> s1{ carr,  carr + 3}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s2{ varr,  varr + 3}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s3{cvarr, cvarr + 3}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<const          int> s4{ varr,  varr + 3}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const          int> s5{cvarr, cvarr + 3}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<      volatile int> s6{ carr,  carr + 3}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    std::span<      volatile int> s7{cvarr, cvarr + 3}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    }
-
-//  CV wrong (statically sized)
-    {
-    std::span<               int,3> s1{ carr,  carr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<               int,3> s2{ varr,  varr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<               int,3> s3{cvarr, cvarr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<const          int,3> s4{ varr,  varr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<const int, 3>'}}
-    std::span<const          int,3> s5{cvarr, cvarr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<const int, 3>'}}
-    std::span<      volatile int,3> s6{ carr,  carr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
-    std::span<      volatile int,3> s7{cvarr, cvarr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
-    }
-
-    // explicit constructor necessary
-    {
-    createImplicitSpan<int, 1>(arr, arr + 1);
-    }
-
-  return 0;
-}

libcxx/test/std/containers/views/span.cons/ptr_ptr.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++03, c++11, c++14, c++17
-
-// <span>
-
-// constexpr span(pointer first, pointer last);
-// Requires: [first, last) shall be a valid range.
-//   If extent is not equal to dynamic_extent, then last - first shall be equal to extent.
-//
-
-#include <span>
-#include <cassert>
-#include <string>
-
-#include "test_macros.h"
-
-void checkCV()
-{
-                   int   arr[] = {1,2,3};
-    const          int  carr[] = {4,5,6};
-          volatile int  varr[] = {7,8,9};
-    const volatile int cvarr[] = {1,3,5};
-
-//  Types the same (dynamic sized)
-    {
-    std::span<               int> s1{  arr,   arr + 3}; // a span<               int> pointing at int.
-    std::span<const          int> s2{ carr,  carr + 3}; // a span<const          int> pointing at const int.
-    std::span<      volatile int> s3{ varr,  varr + 3}; // a span<      volatile int> pointing at volatile int.
-    std::span<const volatile int> s4{cvarr, cvarr + 3}; // a span<const volatile int> pointing at const volatile int.
-    assert(s1.size() + s2.size() + s3.size() + s4.size() == 12);
-    }
-
-//  Types the same (static sized)
-    {
-    std::span<               int,3> s1{  arr,   arr + 3};   // a span<               int> pointing at int.
-    std::span<const          int,3> s2{ carr,  carr + 3};   // a span<const          int> pointing at const int.
-    std::span<      volatile int,3> s3{ varr,  varr + 3};   // a span<      volatile int> pointing at volatile int.
-    std::span<const volatile int,3> s4{cvarr, cvarr + 3};   // a span<const volatile int> pointing at const volatile int.
-    assert(s1.size() + s2.size() + s3.size() + s4.size() == 12);
-    }
-
-
-//  types different (dynamic sized)
-    {
-    std::span<const          int> s1{ arr,  arr + 3};       // a span<const          int> pointing at int.
-    std::span<      volatile int> s2{ arr,  arr + 3};       // a span<      volatile int> pointing at int.
-    std::span<      volatile int> s3{ arr,  arr + 3};       // a span<      volatile int> pointing at const int.
-    std::span<const volatile int> s4{ arr,  arr + 3};       // a span<const volatile int> pointing at int.
-    std::span<const volatile int> s5{carr, carr + 3};       // a span<const volatile int> pointing at const int.
-    std::span<const volatile int> s6{varr, varr + 3};       // a span<const volatile int> pointing at volatile int.
-    assert(s1.size() + s2.size() + s3.size() + s4.size() + s5.size() + s6.size() == 18);
-    }
-
-//  types different (static sized)
-    {
-    std::span<const          int,3> s1{ arr,  arr + 3}; // a span<const          int> pointing at int.
-    std::span<      volatile int,3> s2{ arr,  arr + 3}; // a span<      volatile int> pointing at int.
-    std::span<      volatile int,3> s3{ arr,  arr + 3}; // a span<      volatile int> pointing at const int.
-    std::span<const volatile int,3> s4{ arr,  arr + 3}; // a span<const volatile int> pointing at int.
-    std::span<const volatile int,3> s5{carr, carr + 3}; // a span<const volatile int> pointing at const int.
-    std::span<const volatile int,3> s6{varr, varr + 3}; // 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()
-{
-    constexpr T val[2] = {};
-    std::span<const T>   s1{val, val+2};
-    std::span<const T,2> s2{val, val+2};
-    return
-        s1.data() == &val[0] && s1.size() == 2
-    &&  s2.data() == &val[0] && s2.size() == 2;
-}
-
-
-template <typename T>
-void testRuntimeSpan()
-{
-    T val[2] = {};
-    std::span<T>   s1{val, val+2};
-    std::span<T,2> s2{val, val+2};
-    assert(s1.data() == &val[0] && s1.size() == 2);
-    assert(s2.data() == &val[0] && s2.size() == 2);
-}
-
-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>();
-
-    checkCV();
-
-  return 0;
-}

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

+//===------------------------------ 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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <span>
+
+//  template<class R>
+//    constexpr explicit(extent != dynamic_extent) span(R&& r);
+//
+// Let U be remove_reference_t<ranges::range_reference_t<R>>.
+// Remarks: This constructor shall not participate in overload resolution unless:
+//   - R satisfies ranges::contiguous_range and ranges::sized_range,
+//   - Either R satisfies ranges::borrowed_range or is_const_v<element_type> is true,
+//   - remove_cvref_t<R> is not a specialization of span,
+//   - remove_cvref_t<R> is not a specialization of array,
+//   — is_array_v<remove_cvref_t<R>> is false,
+//   - is_convertible_v<rU(*)[], element_type(*)[] is true
+
+
+#include <span>
+#include <cassert>
+#include <deque>
+#include <ranges>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+template <class T, size_t Extent>
+constexpr bool test_from_range() {
+  T val[3]{};
+  std::span<T, Extent> s{val};
+  assert(s.size() == std::size(val));
+  assert(s.data() == std::data(val));
+  return true;
+}
+
+struct A {};
+
+constexpr bool test() {
+  assert((test_from_range<int, std::dynamic_extent>()));
+  assert((test_from_range<int, 3>()));
+  assert((test_from_range<A, std::dynamic_extent>()));
+  assert((test_from_range<A, 3>()));
+  return true;
+}
+
+static_assert(!std::is_constructible_v<std::span<int>, std::vector<float>&>);    // wrong type
+static_assert(!std::is_constructible_v<std::span<int, 3>, std::vector<float>&>); // wrong type
+
+static_assert(std::is_constructible_v<std::span<int>, std::vector<int>&>);                // non-borrowed lvalue
+static_assert(std::is_constructible_v<std::span<int, 3>, std::vector<int>&>);             // non-borrowed lvalue
+static_assert(!std::is_constructible_v<std::span<int>, const std::vector<int>&>);         // non-borrowed const lvalue
+static_assert(!std::is_constructible_v<std::span<int, 3>, const std::vector<int>&>);      // non-borrowed const lvalue
+static_assert(std::is_constructible_v<std::span<const int>, const std::vector<int>&>);    // non-borrowed const lvalue
+static_assert(std::is_constructible_v<std::span<const int, 3>, const std::vector<int>&>); // non-borrowed const lvalue
+static_assert(std::is_constructible_v<std::span<const int>, std::vector<int>&>);          // non-borrowed lvalue
+static_assert(std::is_constructible_v<std::span<const int, 3>, std::vector<int>&>);       // non-borrowed lvalue
+static_assert(!std::is_constructible_v<std::span<int>, std::vector<int>&&>);              // non-borrowed rvalue
+static_assert(!std::is_constructible_v<std::span<int, 3>, std::vector<int>&&>);           // non-borrowed rvalue
+static_assert(!std::is_constructible_v<std::span<int>, std::deque<int>&>);                // non-contiguous lvalue
+static_assert(!std::is_constructible_v<std::span<int, 3>, std::deque<int>&>);             // non-contiguous lvalue
+static_assert(!std::is_constructible_v<
+              std::span<int>, std::ranges::subrange<std::deque<int>::iterator,
+                                                    std::deque<int>::iterator>&&>); // non-contiguous borrowed rvalue
+static_assert(!std::is_constructible_v<
+              std::span<int, 3>, std::ranges::subrange<std::deque<int>::iterator,
+                                                       std::deque<int>::iterator>&&>); // non-contiguous borrowed rvalue
+
+using BorrowedContiguousSizedRange = std::string_view;
+static_assert(std::is_constructible_v<std::span<const char>, BorrowedContiguousSizedRange>);
+static_assert(std::is_constructible_v<std::span<const char, 3>, BorrowedContiguousSizedRange>);
+static_assert(!std::is_constructible_v<std::span<char>, BorrowedContiguousSizedRange>);
+static_assert(!std::is_constructible_v<std::span<char, 3>, BorrowedContiguousSizedRange>);
+
+static_assert(std::is_convertible_v<BorrowedContiguousSizedRange&, std::span<const char> >);
+static_assert(!std::is_convertible_v<BorrowedContiguousSizedRange&, std::span<const char, 3> >);
+static_assert(!std::is_convertible_v<BorrowedContiguousSizedRange&, std::span<char> >);
+static_assert(!std::is_convertible_v<BorrowedContiguousSizedRange&, std::span<char, 3> >);
+static_assert(std::is_convertible_v<const BorrowedContiguousSizedRange&, std::span<const char> >);
+static_assert(!std::is_convertible_v<const BorrowedContiguousSizedRange&, std::span<const char, 3> >);
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}