[libc++] Simplify span specializations

[jloser]

Summary

span has a partial class template specialization for when the extent
is dynamic. This leads to a lot of repeated code (for type aliases,
constraints on constructors, etc.) which is not ideal. It makes for more
of a maintenance burden as more things are added to span such as
current work I'm doing with P1394.

Refactor span to be just one class template and handle the few differences
between static and dynamic extents with appropriate constraints and
if constexpr where needed. Only store the extent data member when the extent
is dynamic. This ensures no additional storage overhead when the span has a
static extent.

[mclow.lists]

When I wrote span, I tried to do it this way, and I found that it led to much more complicated code.
Maybe span has changed enough that this is no longer true - dunno.

Stuff like this became much easier:

return span<ElementType, see below>(
data() + Offset, Count != dynamic_extent ? Count : size() - Offset);

Remarks: The second template argument of the returned span type is:
Count != dynamic_extent ? Count
: (Extent != dynamic_extent ? Extent - Offset
: dynamic_extent)

[jloser]

Try to fix CI

[curdeius]

libcxx/include/span

320

I don't think it changes anything, but I'd like to have a confirmation here from anyone knowing better the standardese. Does it change anything to have explicitly defaulted destructor vs. implicitly defaulted one?

440–441

To avoid an ABI break in the case of static extent, you suppose that [[no_unique_address]] will be honoured by the compiler, right?
Because otherwise, the size of span<T, N> (N != dynamic_extent) would change.
Unless I'm mistaken, MSVC doesn't honour this attribute unless forced (cf. https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/#msvc-extensions-and-abi).
Not sure whether that's a problem though.

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

50

Where did the array is too large message came from before? Why doesn't it show up with this change?

[jloser]

Use base class instead of [[no_unique_address]] to avoid potential ABI break on MSVC

libcxx/include/span

320

This isn't strictly required to be uncommented in this patch. I added tests for the destructor behavior the other day in D109286 and noted the implicitly defaulted one is sufficient. I just didn't love having it commented out here, but I don't feel strongly at all.

If someone (@Quuxplusone @ldionne or others) suspect this would be an issue, we can do something about it.

440–441

Right. We can't have an ABI break here and that was my intent with use of [[no_unique_address]]. The blog post you linked and the GitHub issue it mentions has me a bit worried.

With that being said, I'm going to just use a base class to avoid an ABI break. I would prefer to use [[no_unique_address]], but playing things safe is my preference here.

I will note that we unconditionally use [[no_unique_address]] in several of ranges things that are C++20-only; it's slightly different than span though as span has been shipping for a few years now.

[jloser]

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

50

In the previous code, an error diagnostic of

Line 232: array is too large (18446744073709551614 elements)

would have been given in checking this constructor.

In the new code, I'm not entirely sure why we don't get that additional constructor error in the list of errors diagnostics. Note that the static_assert still fires for the "Offset + count out of range in span::subspan()". I poked around a bit, but couldn't get it to trigger the additional constructor error about the array size. Do you or others have an idea why?

[• Quuxplusone]

libcxx/include/span

440–441

Maybe I'm missing something, but isn't the base-class approach super obviously an ABI break? The old libc++ code stored "pointer, then size" and this PR's code stores "size, then pointer".

Also, storing members in a dependent base class means a lot more this-> noise in member functions.

If we're just worried about the difficulty of dealing with two very similar copies of the same code, how about we just move the specializations into __span/static_extent.h and __span/dynamic_extent.h, and then try to minimize the diff between them?

Or, do nothing. I'm still unclear on what is the benefit here or how this relates to enable_if or whatever was being talked about earlier.

[jloser]

libcxx/include/span

440–441

No, you're right regarding the ABI break. Having the base class means we'll change the layout which is an obvious ABI break and we can't do that.

My initial worry was indeed in dealing with two very similar copies of the code. I'm not thrilled with how similar the two specializations are, but I think I'll implement P1394 and see what the divergence looks like then and revisit this. We could conditionally define the macro for no_unique_address to workaround MSVC to avoid the ABI break there and go that approach.

In any case, I'm going to abandon this review for now and think about this some more - may revisit after P1394.

libcxx/include/span

struct __is_span_compatible_container<_Tp, _ElementType,
         // remove_pointer_t<decltype(data(cont))>(*)[] is convertible to ElementType(*)[]
             typename enable_if<
                 is_convertible_v<remove_pointer_t<decltype(data(declval<_Tp &>()))>(*)[],
                                  _ElementType(*)[]>,
                 nullptr_t>::type
         >>
     : public true_type {};
 
+template <size_t _Extent>
+class __extent_storage {
+  public:
+    constexpr __extent_storage([[maybe_unused]] size_t __size) noexcept {}
+
+    static constexpr size_t _extent() noexcept { return _Extent; }
+};
+
+template<>
+class __extent_storage<dynamic_extent>
+{
+public:
+  constexpr __extent_storage(size_t __size) noexcept : __extent{__size} {}
+
+  constexpr size_t _extent() const noexcept { return __extent; }
+
+private:
+  size_t __extent{};
+};
 
 template <typename _Tp, size_t _Extent>
-class _LIBCPP_TEMPLATE_VIS span {
+class _LIBCPP_TEMPLATE_VIS span : private __extent_storage<_Extent> {
+  template <size_t _Offset, size_t _Count>
+  static constexpr size_t __subspan_extent()
+  {
+    if constexpr(_Count != dynamic_extent) {
+      return _Count;
+    } else if constexpr(_Extent != dynamic_extent) {
+      return _Extent - _Offset;
+    } else {
+      return dynamic_extent;
+    }
+  }
+
+  using __Extent_Base = __extent_storage<_Extent>;
+
 public:
 //  constants and types
     using element_type           = _Tp;
     using value_type             = remove_cv_t<_Tp>;
     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 &;
 #if (_LIBCPP_DEBUG_LEVEL == 2) || defined(_LIBCPP_ABI_SPAN_POINTER_ITERATORS)
     using iterator               = pointer;
 #else
     using iterator               = __wrap_iter<pointer>;
 #endif
     using reverse_iterator       = _VSTD::reverse_iterator<iterator>;
 
     static constexpr size_type extent = _Extent;
 
 // [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} {}
+    template <size_t _Sz = _Extent, enable_if_t<_Sz == 0 || _Sz == dynamic_extent, nullptr_t> = nullptr>
+    _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept :  __Extent_Base{0}, __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)"); }
+    _LIBCPP_INLINE_VISIBILITY constexpr explicit(extent != dynamic_extent) span(pointer __ptr, size_type __count)
+      : __Extent_Base{__count}, __data{__ptr}  {
+        if constexpr(extent != dynamic_extent) {
+          _LIBCPP_ASSERT(_Extent == __count, "size mismatch in span's constructor (ptr, len)");
+        }
+      }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr span(element_type (&__arr)[_Extent])          noexcept : __data{__arr} {}
+    _LIBCPP_INLINE_VISIBILITY constexpr explicit(extent != dynamic_extent) span(pointer __f, pointer __l)
+      : __Extent_Base{static_cast<size_t>(distance(__f, __l))}, __data{__f}  {
+        if constexpr(extent != dynamic_extent) {
+          _LIBCPP_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)");
+        }
+      }
 
-    template <class _OtherElementType,
+    template <size_t _Sz, enable_if_t<extent == _Sz || extent == dynamic_extent, nullptr_t> = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr span(element_type (&__arr)[_Sz]) noexcept  : __Extent_Base{_Sz}, __data{__arr} {}
+
+    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, _Extent>& __arr) noexcept : __data{__arr.data()} {}
+    constexpr span(array<_OtherElementType, _Sz>& __arr) noexcept : __Extent_Base{_Sz}, __data{__arr.data()} {}
 
-    template <class _OtherElementType,
+    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, _Extent>& __arr) noexcept : __data{__arr.data()} {}
+    constexpr span(const array<_OtherElementType, _Sz>& __arr) noexcept : __Extent_Base{_Sz}, __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)} {
+        : __Extent_Base{static_cast<size_type>(_VSTD::size(__c))}, __data{_VSTD::data(__c)} {
+          if constexpr(extent != dynamic_extent) {
             _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)} {
+        : __Extent_Base{static_cast<size_type>(_VSTD::size(__c))}, __data{_VSTD::data(__c)} {
+          if constexpr(extent != dynamic_extent) {
             _LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (range)");
           }
+        }
 
-    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()} {}
-
-    template <class _OtherElementType>
+    template <class _OtherElementType, size_t _OtherExtent>
     _LIBCPP_INLINE_VISIBILITY
-        constexpr explicit span(const span<_OtherElementType, dynamic_extent>& __other,
+        constexpr explicit span(const span<_OtherElementType, _OtherExtent>& __other,
                        enable_if_t<
                           is_convertible_v<_OtherElementType(*)[], element_type (*)[]>,
                           nullptr_t> = nullptr) noexcept
-        : __data{__other.data()} { _LIBCPP_ASSERT(_Extent == __other.size(), "size mismatch in span's constructor (other span)"); }
-
+        : __Extent_Base{__other.size()}, __data{__other.data()} {
+        if constexpr(_Extent != dynamic_extent) {
+           _LIBCPP_ASSERT(_Extent == __other.size(), "size mismatch in span's constructor (other span)");
+        }
+    }
 
-//  ~span() noexcept = default;
+    ~span() noexcept = default;
 
     template <size_t _Count>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span<element_type, _Count> first() const noexcept
     {
+        if constexpr(extent == dynamic_extent) {
+          _LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::first()");
+        } else {
           static_assert(_Count <= _Extent, "Count out of range in span::first()");
+        }
         return span<element_type, _Count>{data(), _Count};
     }
 
     template <size_t _Count>
     _LIBCPP_INLINE_VISIBILITY
     constexpr span<element_type, _Count> last() const noexcept
     {
+        if constexpr(extent == dynamic_extent) {
+          _LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::last()");
+        } else {
           static_assert(_Count <= _Extent, "Count out of range in span::last()");
+        }
         return span<element_type, _Count>{data() + size() - _Count, _Count};
     }
 
     _LIBCPP_INLINE_VISIBILITY
     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(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>
+    constexpr auto subspan() const noexcept -> span<element_type, __subspan_extent<_Offset, _Count>()>
     {
         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()");
 
-        using _ReturnType = span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>;
+        if constexpr(_Count == dynamic_extent) {
+          _LIBCPP_ASSERT(_Offset <= size(), "Offset out of range in span::subspan()");
+          _LIBCPP_ASSERT(_Count == dynamic_extent || _Count <= size() - _Offset, "Offset + count out of range in span::subspan()");
+        }
+
+        using _ReturnType = span<element_type, __subspan_extent<_Offset, _Count>()>;
         return _ReturnType{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
     }
 
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr span<element_type, dynamic_extent>
        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(__count <= size() - __offset, "Offset + count out of range in span::subspan(offset, count)");
         return {data() + __offset, __count};
     }
 
-    _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 size_type size()       const noexcept { return static_cast<const __Extent_Base&>(*this)._extent(); }
+    _LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return static_cast<const __Extent_Base&>(*this)._extent() * sizeof(element_type); }
+    _LIBCPP_INLINE_VISIBILITY constexpr bool empty()           const noexcept { return static_cast<const __Extent_Base&>(*this)._extent() == 0; }
 
     _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
     {
         _LIBCPP_ASSERT(__idx < size(), "span<T,N>[] index out of bounds");
         return __data[__idx];
     }
 
     _LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
// [span.cons], span constructors, copy, assignment, and destructor
     _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 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 span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept
-    { return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte *>(data()), size_bytes()}; }
-
-    _LIBCPP_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept
-    { return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte *>(data()), size_bytes()}; }
-
-private:
-    pointer    __data;
-
-};
-
-
-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 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 &;
-#if (_LIBCPP_DEBUG_LEVEL == 2) || defined(_LIBCPP_ABI_SPAN_POINTER_ITERATORS)
-    using iterator               = pointer;
-#else
-    using iterator               = __wrap_iter<pointer>;
-#endif
-    using reverse_iterator       = _VSTD::reverse_iterator<iterator>;
-
-    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 <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)} {}
-
-
-    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()");
-        return span<element_type, _Count>{data(), _Count};
-    }
-
-    template <size_t _Count>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, _Count> last() const noexcept
-    {
-        _LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::last()");
-        return span<element_type, _Count>{data() + size() - _Count, _Count};
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    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 (size_type __count) const noexcept
+    _LIBCPP_INLINE_VISIBILITY span<const byte, _Extent == dynamic_extent ? dynamic_extent : _Extent * sizeof(element_type)>
+    __as_bytes() const noexcept
     {
-        _LIBCPP_ASSERT(__count <= size(), "Count out of range in span::last(count)");
-        return {data() + size() - __count, __count};
+      if constexpr(_Extent  == dynamic_extent) {
+        return span<const byte, dynamic_extent>{reinterpret_cast<const byte *>(data()), size_bytes()};
+      } else {
+        return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte *>(data()), size_bytes()};
       }
-
-    template <size_t _Offset, size_t _Count = dynamic_extent>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, _Count> subspan() const noexcept
-    {
-        _LIBCPP_ASSERT(_Offset <= size(), "Offset out of range in span::subspan()");
-        _LIBCPP_ASSERT(_Count == dynamic_extent || _Count <= size() - _Offset, "Offset + count out of range in span::subspan()");
-        return span<element_type, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
-    }
-
-    constexpr span<element_type, dynamic_extent>
-    _LIBCPP_INLINE_VISIBILITY
-    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(__count <= size() - __offset, "Offset + count out of range in span::subspan(offset, count)");
-        return {data() + __offset, __count};
-    }
-
-    _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[](size_type __idx) const noexcept
-    {
-        _LIBCPP_ASSERT(__idx < size(), "span<T>[] index out of bounds");
-        return __data[__idx];
     }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
+    _LIBCPP_INLINE_VISIBILITY span<byte, _Extent == dynamic_extent ? dynamic_extent : _Extent * sizeof(element_type)>
+    __as_writable_bytes() const noexcept
     {
-        _LIBCPP_ASSERT(!empty(), "span<T>[].front() on empty span");
-        return __data[0];
+      if constexpr(_Extent == dynamic_extent) {
+        return span<byte, dynamic_extent>{reinterpret_cast<byte *>(data()), size_bytes()};
+      } else {
+        return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte *>(data()), size_bytes()};
       }
-
-    _LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
-    {
-        _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 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 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;
-    size_type __size;
+    pointer    __data;
 };
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 template <class _Tp, size_t _Extent>
 inline constexpr bool ranges::enable_borrowed_range<span<_Tp, _Extent> > = true;
 
 template <class _ElementType, size_t _Extent>
 inline constexpr bool ranges::enable_view<span<_ElementType, _Extent>> = true;
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)

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

int main(int, char**) {
 
   //  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)}}}}
+    [[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()"}}
   }
 
   return 0;
 }