Guard against overflow in span::subspan

[miscco]

I am just getting used to arcanist so I messed up and created a new revision. What to do here?

Also Can we actually test runtime behavior where there is an assert rather than a static_assert?

[miscco]

• Fix incorrect return type of span::subspan
• Guard against overflow in span::subspan

[miscco]

• Add failing tests for span::first
• Add fail tests for span::last
• Add fail tests for element access of span and improve the error message
• SFINAE span default constructor on Extent == 0

[miscco]

I have added some additional unit tests that should statically fail.

I also SFINAEd out the default constructor if Extent != 0. I did learn how to do that from microsofts STL. Is that a licensing problem @CaseyCarter?

[miscco]

I also believe that we should add a static assert to operator[] similar to front() and back(). Unfortunately there are multiple tests that rely on operator[] of a statically empty span. Thoughts?

[miscco]

• Implement P1872R0

[miscco]

Gentle Ping

[miscco]

Some small comments as I read it again

libcxx/include/span

305

The first condition is trivially true due to the change to size_t (__idx >= 0)

305

We should add a static_assert for _Extent > 0 similar to front() and back()

317

I should remove "[]" same for front()

474

Same here, __idx is a size_tso __idx >= 0 is always true

libcxx/test/std/containers/views/span.elem/elem.fail.cpp

34 ↗

(On Diff #228587)

Should adopt the error message with something like span<T,0>::back()

[miscco]

• [span] Improve eror messages and remove tautological comparison

[mclow.lists]

There's at least three things going on in this patch; and that makes it harder to review:

• Rename all the index_types to size_type.
• Add static_assert to several cases
• Guard against overflow in span::subspan (ostensibly the purpose of this patch).

In the future, this should be three patches.

[mclow.lists]

In D69466#1723982, @miscco wrote:

I also believe that we should add a static assert to operator[] similar to front() and back(). Unfortunately there are multiple tests that rely on operator[] of a statically empty span. Thoughts?

I assume that you're talking about the case where _Extent == 0 - is that correct?
If the tests are calling operator[] on a span<T, 0>, then they are incorrect and should be changed.

[mclow.lists]

In D69466#1786043, @mclow.lists wrote:

If the tests are calling operator[] on a span<T, 0>, then they are incorrect and should be changed.

Note that this is independent of whether or not we should add a static_assert to operator[].

[miscco]

Scrap my comment about invalid access to an empty span. Adding a static assert to operator[] fails due to evaulation of both branches during compilation:

cpp
    if (s.empty())
    {
        ret = ret &&  ( b ==  s.end());
        ret = ret &&  (cb == s.cend());
    }
    else
    {
        ret = ret &&  (  *b ==  s[0]);
        ret = ret &&  ( &*b == &s[0]);
        ret = ret &&  ( *cb ==  s[0]);
        ret = ret &&  (&*cb == &s[0]);
    }

The code in question is obviously correct. So I guess one would need to guard such checks with if (!std::is_constant_evaluated()) which seems a bit over the top.

Otherwise, I would need to revert the static_asserts in front() and back() as they would also trigger in a similar case.

Thoughts?

[miscco]

• [libcxx] span: Remove incorrect static_asserts

[miscco]

I removed the static_assert from the front() and back() method and added the appropriate _LIBCPP_ASSERT instead.

The problem is that the following code would otherwise break:

if (!s.empty()) {
    s.front()
}

As far as I understand we cannot use is_constant_evaluated() as that would still require the compiler to process the branch and trigger the static_assert

[miscco]

In order to facilitate the adoption of the changes I have created atomic revisions of the individual changes and will drop this one.

libcxx/include/span

 
 namespace std {
 template <class ElementType, size_t Extent = dynamic_extent>
 class span {
 public:
     // constants and types
     using element_type = ElementType;
     using value_type = remove_cv_t<ElementType>;
-    using index_type = size_t;
+    using size_type = size_t;
     using difference_type = ptrdiff_t;
     using pointer = element_type*;
     using const_pointer = const element_type*;
     using reference = element_type&;
     using const_reference = const element_type&;
     using iterator = implementation-defined;
     using const_iterator = implementation-defined;
     using reverse_iterator = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-    static constexpr index_type extent = Extent;
+    static constexpr size_type extent = Extent;
 
     // [span.cons], span constructors, copy, assignment, and destructor
     constexpr span() noexcept;
-    constexpr span(pointer ptr, index_type count);
+    constexpr span(pointer ptr, size_type count);
     constexpr span(pointer firstElem, pointer lastElem);
     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>
public:
     // [span.sub], span subviews
     template <size_t Count>
         constexpr span<element_type, Count> first() const;
     template <size_t Count>
         constexpr span<element_type, Count> last() const;
     template <size_t Offset, size_t Count = dynamic_extent>
         constexpr span<element_type, see below> subspan() const;
 
-    constexpr span<element_type, dynamic_extent> first(index_type count) const;
-    constexpr span<element_type, dynamic_extent> last(index_type count) const;
-    constexpr span<element_type, dynamic_extent> subspan(index_type offset, index_type count = dynamic_extent) const;
+    constexpr span<element_type, dynamic_extent> first(size_type count) const;
+    constexpr span<element_type, dynamic_extent> last(size_type count) const;
+    constexpr span<element_type, dynamic_extent> subspan(size_type offset, size_type count = dynamic_extent) const;
 
     // [span.obs], span observers
-    constexpr index_type size() const noexcept;
-    constexpr index_type size_bytes() const noexcept;
+    constexpr size_type size() const noexcept;
+    constexpr size_type size_bytes() const noexcept;
     constexpr bool empty() const noexcept;
 
     // [span.elem], span element access
-    constexpr reference operator[](index_type idx) const;
+    constexpr reference operator[](size_type idx) const;
     constexpr reference front() const;
     constexpr reference back() const;
     constexpr pointer data() const noexcept;
 
     // [span.iterators], span iterator support
     constexpr iterator begin() const noexcept;
     constexpr iterator end() const noexcept;
     constexpr const_iterator cbegin() const noexcept;
     constexpr const_iterator cend() const noexcept;
     constexpr reverse_iterator rbegin() const noexcept;
     constexpr reverse_iterator rend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
 
 private:
     pointer data_;     // exposition only
-    index_type size_;  // exposition only
+    size_type size_;  // exposition only
 };
 
 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 <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 index_type             = size_t;
+    using size_type              = size_t;
     using difference_type        = ptrdiff_t;
     using pointer                = _Tp *;
     using const_pointer          = const _Tp *;
     using reference              = _Tp &;
     using const_reference        = const _Tp &;
     using iterator               =  __wrap_iter<pointer>;
     using const_iterator         =  __wrap_iter<const_pointer>;
     using reverse_iterator       = _VSTD::reverse_iterator<iterator>;
     using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
 
-    static constexpr index_type extent = _Extent;
+    static constexpr size_type extent = _Extent;
 
 // [span.cons], span constructors, copy, assignment, and destructor
-    _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}
-    { static_assert(_Extent == 0, "Can't default construct a statically sized span with size > 0"); }
+    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 span(pointer __ptr, index_type __count) : __data{__ptr}
+    _LIBCPP_INLINE_VISIBILITY constexpr 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 span(pointer __f, pointer __l) : __data{__f}
         { (void)__l;     _LIBCPP_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)"); }
 
     _LIBCPP_INLINE_VISIBILITY constexpr span(element_type (&__arr)[_Extent])          noexcept : __data{__arr} {}
     _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()} {}
 
//  ~span() noexcept = default;
     _LIBCPP_INLINE_VISIBILITY
     constexpr span<element_type, _Count> last() const noexcept
     {
         static_assert(_Count <= _Extent, "Count out of range in span::last()");
         return {data() + size() - _Count, _Count};
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent> first(index_type __count) const noexcept
+    constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept
     {
         _LIBCPP_ASSERT(__count <= size(), "Count out of range in span::first(count)");
         return {data(), __count};
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent> last(index_type __count) const noexcept
+    constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept
     {
         _LIBCPP_ASSERT(__count <= size(), "Count out of range in span::last(count)");
         return {data() + size() - __count, __count};
     }
 
     template <size_t _Offset, size_t _Count = dynamic_extent>
     _LIBCPP_INLINE_VISIBILITY
     constexpr auto subspan() const noexcept
         -> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>
     {
         static_assert(_Offset <= _Extent, "Offset out of range in span::subspan()");
+        static_assert(_Count == dynamic_extent || _Count <= _Extent - _Offset, "Offset + count out of range in span::subspan()");
         return {data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
     }
 
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr span<element_type, dynamic_extent>
-       subspan(index_type __offset, index_type __count = dynamic_extent) const noexcept
+       subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept
     {
         _LIBCPP_ASSERT(__offset <= size(), "Offset out of range in span::subspan(offset, count)");
         _LIBCPP_ASSERT(__count  <= size() || __count == dynamic_extent, "Count out of range in span::subspan(offset, count)");
         if (__count == dynamic_extent)
             return {data() + __offset, size() - __offset};
-        _LIBCPP_ASSERT(__offset <= size() - __count, "count + offset out of range in span::subspan(offset, count)");
+        _LIBCPP_ASSERT(__count <= size() - __offset, "Offset + count out of range in span::subspan(offset, count)");
         return {data() + __offset, __count};
     }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr index_type size()       const noexcept { return _Extent; }
-    _LIBCPP_INLINE_VISIBILITY constexpr index_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }
+    _LIBCPP_INLINE_VISIBILITY constexpr size_type size()       const noexcept { return _Extent; }
+    _LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }
     _LIBCPP_INLINE_VISIBILITY constexpr bool empty()            const noexcept { return _Extent == 0; }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](index_type __idx) const noexcept
+    _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
     {
-        _LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T,N>[] index out of bounds");
+        _LIBCPP_ASSERT(__idx < size(), "span<T,N>[] index out of bounds");
         return __data[__idx];
     }
 
     _LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
     {
-        static_assert(_Extent > 0, "span<T,N>[].front() on empty span");
+        _LIBCPP_ASSERT(!empty(), "span<T>::front() on empty span");
         return __data[0];
     }
 
     _LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
     {
-        static_assert(_Extent > 0, "span<T,N>[].back() on empty span");
+        _LIBCPP_ASSERT(!empty(), "span<T>::back() on empty span");
         return __data[size()-1];
     }
 
     _LIBCPP_INLINE_VISIBILITY constexpr pointer data()                         const noexcept { return __data; }
 
 // [span.iter], span iterator support
     _LIBCPP_INLINE_VISIBILITY constexpr iterator                 begin() const noexcept { return iterator(data()); }
     _LIBCPP_INLINE_VISIBILITY constexpr iterator                   end() const noexcept { return iterator(data() + size()); }

 template <typename _Tp>
 class _LIBCPP_TEMPLATE_VIS span<_Tp, dynamic_extent> {
 private:
 
 public:
 //  constants and types
     using element_type           = _Tp;
     using value_type             = remove_cv_t<_Tp>;
-    using index_type             = size_t;
+    using size_type              = size_t;
     using difference_type        = ptrdiff_t;
     using pointer                = _Tp *;
     using const_pointer          = const _Tp *;
     using reference              = _Tp &;
     using const_reference        = const _Tp &;
     using iterator               =  __wrap_iter<pointer>;
     using const_iterator         =  __wrap_iter<const_pointer>;
     using reverse_iterator       = _VSTD::reverse_iterator<iterator>;
     using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
 
-    static constexpr index_type extent = dynamic_extent;
+    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, index_type __count) : __data{__ptr}, __size{__count} {}
+    _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 <size_t _Sz>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(element_type (&__arr)[_Sz])          noexcept : __data{__arr}, __size{_Sz} {}
 
     template <size_t _Sz>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(array<value_type, _Sz>& __arr)       noexcept : __data{__arr.data()}, __size{_Sz} {}
 
     template <size_t _Sz>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span(const array<value_type, _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{(index_type) _VSTD::size(__c)} {}
+        : __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{(index_type) _VSTD::size(__c)} {}
+        : __data{_VSTD::data(__c)}, __size{(size_type) _VSTD::size(__c)} {}
 
 
     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
//    ~span() noexcept = default;
     _LIBCPP_INLINE_VISIBILITY
     constexpr span<element_type, _Count> last() const noexcept
     {
         _LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::last()");
         return {data() + size() - _Count, _Count};
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent> first(index_type __count) const noexcept
+    constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept
     {
         _LIBCPP_ASSERT(__count <= size(), "Count out of range in span::first(count)");
         return {data(), __count};
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent> last (index_type __count) const noexcept
+    constexpr span<element_type, dynamic_extent> last (size_type __count) const noexcept
     {
         _LIBCPP_ASSERT(__count <= size(), "Count out of range in span::last(count)");
         return {data() + size() - __count, __count};
     }
 
     template <size_t _Offset, size_t _Count = dynamic_extent>
     _LIBCPP_INLINE_VISIBILITY
-    constexpr span<_Tp, dynamic_extent> subspan() const noexcept
+    constexpr span<element_type, _Count> subspan() const noexcept
     {
         _LIBCPP_ASSERT(_Offset <= size(), "Offset out of range in span::subspan()");
-        _LIBCPP_ASSERT(_Count == dynamic_extent || _Offset + _Count <= size(), "Count out of range in span::subspan()");
+        _LIBCPP_ASSERT(_Count == dynamic_extent || _Count <= size() - _Offset, "Offset + count out of range in span::subspan()");
         return {data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
     }
 
     constexpr span<element_type, dynamic_extent>
     _LIBCPP_INLINE_VISIBILITY
-    subspan(index_type __offset, index_type __count = dynamic_extent) const noexcept
+    subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept
     {
         _LIBCPP_ASSERT(__offset <= size(), "Offset out of range in span::subspan(offset, count)");
         _LIBCPP_ASSERT(__count  <= size() || __count == dynamic_extent, "count out of range in span::subspan(offset, count)");
         if (__count == dynamic_extent)
             return {data() + __offset, size() - __offset};
-        _LIBCPP_ASSERT(__offset <= size() - __count, "Offset + count out of range in span::subspan(offset, count)");
+        _LIBCPP_ASSERT(__count <= size() - __offset, "Offset + count out of range in span::subspan(offset, count)");
         return {data() + __offset, __count};
     }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr index_type size()       const noexcept { return __size; }
-    _LIBCPP_INLINE_VISIBILITY constexpr index_type size_bytes() const noexcept { return __size * sizeof(element_type); }
+    _LIBCPP_INLINE_VISIBILITY constexpr size_type size()       const noexcept { return __size; }
+    _LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return __size * sizeof(element_type); }
     _LIBCPP_INLINE_VISIBILITY constexpr bool empty()            const noexcept { return __size == 0; }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](index_type __idx) const noexcept
+    _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
     {
-        _LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T>[] index out of bounds");
+        _LIBCPP_ASSERT(__idx < size(), "span<T>::operator[] index out of bounds");
         return __data[__idx];
     }
 
     _LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
     {
-        _LIBCPP_ASSERT(!empty(), "span<T>[].front() on empty span");
+        _LIBCPP_ASSERT(!empty(), "span<T>::front() on empty span");
         return __data[0];
     }
 
     _LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
     {
-        _LIBCPP_ASSERT(!empty(), "span<T>[].back() on empty span");
+        _LIBCPP_ASSERT(!empty(), "span<T>::back() on empty span");
         return __data[size()-1];
     }
 
 
     _LIBCPP_INLINE_VISIBILITY constexpr pointer data()                         const noexcept { return __data; }
 
 // [span.iter], span iterator support
     _LIBCPP_INLINE_VISIBILITY constexpr iterator                 begin() const noexcept { return iterator(data()); }
     _LIBCPP_INLINE_VISIBILITY constexpr iterator                   end() const noexcept { return iterator(data() + size()); }
     _LIBCPP_INLINE_VISIBILITY constexpr const_iterator          cbegin() const noexcept { return const_iterator(data()); }
     _LIBCPP_INLINE_VISIBILITY constexpr const_iterator            cend() const noexcept { return const_iterator(data() + size()); }
     _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator        rbegin() const noexcept { return reverse_iterator(end()); }
     _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator          rend() const noexcept { return reverse_iterator(begin()); }
     _LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }
     _LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator   crend() const noexcept { return const_reverse_iterator(cbegin()); }
 
     _LIBCPP_INLINE_VISIBILITY constexpr void swap(span &__other) noexcept
     {
         pointer __p = __data;
         __data = __other.__data;
         __other.__data = __p;
 
-        index_type __sz = __size;
+        size_type __sz = __size;
         __size = __other.__size;
         __other.__size = __sz;
     }
 
     _LIBCPP_INLINE_VISIBILITY span<const byte, dynamic_extent> __as_bytes() const noexcept
     { return {reinterpret_cast<const byte *>(data()), size_bytes()}; }
 
     _LIBCPP_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writable_bytes() const noexcept
     { return {reinterpret_cast<byte *>(data()), size_bytes()}; }
 
 private:
     pointer    __data;
-    index_type __size;
+    size_type __size;
 };
 
 //  tuple interface
 template <class _Tp, size_t _Size>
 struct _LIBCPP_TEMPLATE_VIS tuple_size<span<_Tp, _Size>>
     : public integral_constant<size_t, _Size> {};
 
 template <class _Tp>

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

 
 
 int main(int, char**)
 {
 
 //  constexpr dynamically sized assignment
     {
 //  On systems where 'ptrdiff_t' is a synonym for 'int',
-//  the call span(ptr, 0) selects the (pointer, index_type) constructor.
+//  the call span(ptr, 0) selects the (pointer, size_type) constructor.
 //  On systems where 'ptrdiff_t' is NOT a synonym for 'int',
 //  it is ambiguous, because of 0 also being convertible to a null pointer
 //  and so the compiler can't choose between:
-//      span(pointer, index_type)
+//      span(pointer, size_type)
 //  and span(pointer, pointer)
 //  We cast zero to std::ptrdiff_t to remove that ambiguity.
 //  Example:
 //      On darwin x86_64, ptrdiff_t is the same as long int.
 //      On darwin i386, ptrdiff_t is the same as int.
         constexpr std::span<const int> spans[] = {
             {},
             {carr1, static_cast<std::size_t>(0)},

libcxx/test/std/containers/views/span.cons/default.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++98, c++03, c++11, c++14, c++17
 
 // <span>
 
 // constexpr span() noexcept;
 //
 //  Remarks: This constructor shall not participate in overload resolution
-//          unless Extent <= 0 is true.
+//          unless Extent == 0 || Extent == dynamic_extent is true.
 
 
 #include <span>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    std::span<int, 2> s; // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Can't default construct a statically sized span with size > 0"}}
-
-//  TODO: This is what I want:
-// eXpected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
+  std::span<int, 2> s; // expected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
 
   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++98, c++03, c++11, c++14, c++17
 
 // <span>
 
-// constexpr span(pointer ptr, index_type count);
+// 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>
 

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++98, c++03, c++11, c++14, c++17
 
 // <span>
 
-// constexpr span(pointer ptr, index_type count);
+// 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>
 

libcxx/test/std/containers/views/span.elem/op_idx.pass.cpp

 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <span>
 
-// constexpr reference operator[](index_type idx) const;
-// constexpr reference operator()(index_type idx) const;
+// constexpr reference operator[](size_type idx) const;
+// constexpr reference operator()(size_type idx) const;
 //
 
 
 #include <span>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"

libcxx/test/std/containers/views/span.iterators/rbegin.pass.cpp

constexpr bool testConstexprSpan(Span s)
     typename Span::const_reverse_iterator cb = s.crbegin();
     if (s.empty())
     {
         ret = ret &&  ( b ==  s.rend());
         ret = ret &&  (cb == s.crend());
     }
     else
     {
-        const typename Span::index_type last = s.size() - 1;
+        const typename Span::size_type last = s.size() - 1;
         ret = ret &&  (  *b ==  s[last]);
         ret = ret &&  ( &*b == &s[last]);
         ret = ret &&  ( *cb ==  s[last]);
         ret = ret &&  (&*cb == &s[last]);
     }
     ret = ret &&  (b == cb);
     return ret;
 }
 
 
 template <class Span>
 void testRuntimeSpan(Span s)
 {
     typename Span::reverse_iterator b        = s. rbegin();
     typename Span::const_reverse_iterator cb = s.crbegin();
     if (s.empty())
     {
         assert( b ==  s.rend());
         assert(cb == s.crend());
     }
     else
     {
-        const typename Span::index_type last = s.size() - 1;
+        const typename Span::size_type last = s.size() - 1;
         assert(  *b ==  s[last]);
         assert( &*b == &s[last]);
         assert( *cb ==  s[last]);
         assert(&*cb == &s[last]);
     }
     assert(b == cb);
 }
 

libcxx/test/std/containers/views/span.obs/size.pass.cpp

 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <span>
 
-// constexpr index_type size() const noexcept;
+// constexpr size_type size() const noexcept;
 //
 
 
 #include <span>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"

libcxx/test/std/containers/views/span.obs/size_bytes.pass.cpp

 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <span>
 
-// constexpr index_type size_bytes() const noexcept;
+// constexpr size_type size_bytes() const noexcept;
 //
 //  Effects: Equivalent to: return size() * sizeof(element_type);
 
 
 #include <span>
 #include <cassert>
 #include <string>
 

libcxx/test/std/containers/views/span.sub/first.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++98, c++03, c++11, c++14, c++17
+
+// <span>
+
+// template<size_t Count>
+//  constexpr span<element_type, Count> first() const;
+//
+// constexpr span<element_type, dynamic_extent> first(size_type count) const;
+//
+//  Requires: 0 <= Count && Count <= size().
+
+#include <span>
+
+#include "test_macros.h"
+
+constexpr int carr[] = {1, 2, 3, 4};
+
+int main(int, char**) {
+  std::span<const int, 4> sp(carr);
+
+  //  Count too large
+  {
+    [[maybe_unused]] auto s1 = sp.first<5>(); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Count out of range in span::first()"}}
+  }
+
+  //  Count numeric_limits
+  {
+    [[maybe_unused]] auto s1 = sp.first<std::size_t(-1)>(); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Count out of range in span::first()"}}
+  }
+
+  return 0;
+}

libcxx/test/std/containers/views/span.sub/first.pass.cpp

 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <span>
 
 // template<size_t Count>
 //  constexpr span<element_type, Count> first() const;
 //
-// constexpr span<element_type, dynamic_extent> first(index_type count) const;
+// constexpr span<element_type, dynamic_extent> first(size_type count) const;
 //
-//  Requires: 0 <= Count && Count <= size().
+//  Requires: Count <= size().
 
 
 #include <span>
 #include <cassert>
 #include <algorithm>
 #include <string>
 
 #include "test_macros.h"

libcxx/test/std/containers/views/span.sub/last.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++98, c++03, c++11, c++14, c++17
+
+// <span>
+
+// template<size_t Count>
+//  constexpr span<element_type, Count> last() const;
+//
+// constexpr span<element_type, dynamic_extent> last(size_type count) const;
+//
+//  Requires: Count <= size().
+
+#include <span>
+
+#include "test_macros.h"
+
+constexpr int carr[] = {1, 2, 3, 4};
+
+int main(int, char**) {
+  std::span<const int, 4> sp(carr);
+
+  //  Count too large
+  {
+    [[maybe_unused]] auto s1 = sp.last<5>(); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Count out of range in span::last()"}}
+  }
+
+  //  Count numeric_limits
+  {
+    [[maybe_unused]] auto s1 = sp.last<std::size_t(-1)>(); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Count out of range in span::last()"}}
+  }
+
+  return 0;
+}

libcxx/test/std/containers/views/span.sub/last.pass.cpp

 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <span>
 
 // template<size_t Count>
 //  constexpr span<element_type, Count> last() const;
 //
-// constexpr span<element_type, dynamic_extent> last(index_type count) const;
+// constexpr span<element_type, dynamic_extent> last(size_type count) const;
 //
-//  Requires: 0 <= Count && Count <= size().
+//  Requires: Count <= size().
 
 
 #include <span>
 #include <cassert>
 #include <algorithm>
 #include <string>
 
 #include "test_macros.h"

libcxx/test/std/containers/views/span.sub/subspan.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++98, c++03, c++11, c++14, c++17
+
+// <span>
+
+// template<size_t Offset, size_t Count = dynamic_extent>
+//   constexpr span<element_type, see below> subspan() const;
+//
+// constexpr span<element_type, dynamic_extent> subspan(
+//   size_type offset, size_type count = dynamic_extent) const;
+//
+//  Requires: offset <= size() &&
+//            (count == dynamic_extent || count <= size() - offset)
+
+#include <span>
+
+#include "test_macros.h"
+
+constexpr int carr[] = {1, 2, 3, 4};
+
+int main(int, char**) {
+  std::span<const int, 4> sp(carr);
+
+  //  Offset too large templatized
+  {
+    [[maybe_unused]] auto s1 = sp.subspan<5>(); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Offset out of range in span::subspan()"}}
+  }
+
+  //  Count too large templatized
+  {
+    [[maybe_unused]] auto s1 = sp.subspan<0, 5>(); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Offset + count out of range in span::subspan()"}}
+  }
+
+  //  Offset + Count too large templatized
+  {
+    [[maybe_unused]] auto s1 = sp.subspan<2, 3>(); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Offset + count out of range in span::subspan()"}}
+  }
+
+  //  Offset + Count overflow templatized
+  {
+    [[maybe_unused]] auto s1 = sp.subspan<3, std::size_t(-2)>(); // expected-error-re@span:* {{static_assert failed{{( due to requirement '.*')?}} "Offset + count out of range in span::subspan()"}}, expected-error-re@span:* {{array is too large{{(.* elements)}}}}
+  }
+
+  return 0;
+}

libcxx/test/std/containers/views/span.sub/subspan.pass.cpp

 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <span>
 
 // template<size_t Offset, size_t Count = dynamic_extent>
 //   constexpr span<element_type, see below> subspan() const;
 //
 // constexpr span<element_type, dynamic_extent> subspan(
-//   index_type offset, index_type count = dynamic_extent) const;
+//   size_type offset, size_type count = dynamic_extent) const;
 //
 //  Requires: (0 <= Offset && Offset <= size())
 //      && (Count == dynamic_extent || Count >= 0 && Offset + Count <= size())
 
 #include <span>
 #include <cassert>
 #include <algorithm>
 #include <string>
 
 #include "test_macros.h"
 
 template <typename Span, size_t Offset, size_t Count>
 constexpr bool testConstexprSpan(Span sp)
 {
     LIBCPP_ASSERT((noexcept(sp.template subspan<Offset, Count>())));
     LIBCPP_ASSERT((noexcept(sp.subspan(Offset, Count))));
     auto s1 = sp.template subspan<Offset, Count>();
     auto s2 = sp.subspan(Offset, Count);
     using S1 = decltype(s1);
     using S2 = decltype(s2);
     ASSERT_SAME_TYPE(typename Span::value_type, typename S1::value_type);
     ASSERT_SAME_TYPE(typename Span::value_type, typename S2::value_type);
-    static_assert(S1::extent == (Span::extent == std::dynamic_extent ? std::dynamic_extent : Count), "");
-    static_assert(S2::extent == std::dynamic_extent, "");
+    static_assert(S1::extent ==
+      ((Count != std::dynamic_extent) ? Count
+                      : ((Span::extent != std::dynamic_extent) ? Span::extent - Offset
+                                           : std::dynamic_extent)), "");
+  static_assert(S2::extent == std::dynamic_extent, "");
     return
         s1.data() == s2.data()
      && s1.size() == s2.size()
      && std::equal(s1.begin(), s1.end(), sp.begin() + Offset);
 }
 
 template <typename Span, size_t Offset>
 constexpr bool testConstexprSpan(Span sp)
void testRuntimeSpan(Span sp)
     LIBCPP_ASSERT((noexcept(sp.template subspan<Offset, Count>())));
     LIBCPP_ASSERT((noexcept(sp.subspan(Offset, Count))));
     auto s1 = sp.template subspan<Offset, Count>();
     auto s2 = sp.subspan(Offset, Count);
     using S1 = decltype(s1);
     using S2 = decltype(s2);
     ASSERT_SAME_TYPE(typename Span::value_type, typename S1::value_type);
     ASSERT_SAME_TYPE(typename Span::value_type, typename S2::value_type);
-    static_assert(S1::extent == (Span::extent == std::dynamic_extent ? std::dynamic_extent : Count), "");
+    static_assert(S1::extent ==
+      ((Count != std::dynamic_extent) ? Count
+                      : ((Span::extent != std::dynamic_extent) ? Span::extent - Offset
+                                           : std::dynamic_extent)), "");
     static_assert(S2::extent == std::dynamic_extent, "");
     assert(s1.data() == s2.data());
     assert(s1.size() == s2.size());
     assert(std::equal(s1.begin(), s1.end(), sp.begin() + Offset));
 }
 
 
 template <typename Span, size_t Offset>

libcxx/test/std/containers/views/types.pass.cpp

 // <span>
 
 // template<class ElementType, size_t Extent = dynamic_extent>
 // class span {
 // public:
 //  // constants and types
 //  using element_type           = ElementType;
 //  using value_type             = remove_cv_t<ElementType>;
-//  using index_type             = size_t;
+//  using size_type              = size_t;
 //  using difference_type        = ptrdiff_t;
 //  using pointer                = element_type *;
 //  using reference              = element_type &;
 //  using const_pointe           = const element_type *;
 //  using const_reference        = const element_type &;
 //  using iterator               = implementation-defined;
 //  using const_iterator         = implementation-defined;
 //  using reverse_iterator       = std::reverse_iterator<iterator>;
 //  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 //
-//  static constexpr index_type extent = Extent;
+//  static constexpr size_type extent = Extent;
 //
 
 #include <span>
 #include <cassert>
 #include <iterator>
 #include <string>
 
 #include "test_macros.h"
//      a const pointer to a non-const value, which is not what I want.
     ASSERT_SAME_TYPE(typename ItT::difference_type,   typename S::difference_type);
 }
 
 template <typename S, typename ElementType, std::size_t Size>
 void testSpan()
 {
     ASSERT_SAME_TYPE(typename S::element_type,    ElementType);
     ASSERT_SAME_TYPE(typename S::value_type,      std::remove_cv_t<ElementType>);
-    ASSERT_SAME_TYPE(typename S::index_type,      std::size_t);
+    ASSERT_SAME_TYPE(typename S::size_type,       std::size_t);
     ASSERT_SAME_TYPE(typename S::difference_type, std::ptrdiff_t);
     ASSERT_SAME_TYPE(typename S::pointer,         ElementType *);
     ASSERT_SAME_TYPE(typename S::const_pointer,   const ElementType *);
     ASSERT_SAME_TYPE(typename S::reference,       ElementType &);
     ASSERT_SAME_TYPE(typename S::const_reference, const ElementType &);
 
     static_assert(S::extent == Size); // check that it exists