[libc++] Rename span's as_writeable_bytes to as_writable_bytes

[ldionne]

Summary

The Standard says as_writable_bytes.

[ldionne]

This is NOT an ABI break because the methods involved have INLINE_VISIBILITY.

This IS an API break because we're renaming a function. However, I suspect that function isn't used all that often, and for those users that will be broken, the fix is trivial (just rename the function). I also know that we haven't been shipping this for a long time, so there isn't like years of code written on top of this bug. This is why I suggest we don't try to retain the old name.

[mclow.lists]

And it is part of C++20, so it's not final anyway.

libcxx/include/span

_LIBCPP_INLINE_VISIBILITY constexpr void swap(span &__other) noexcept
         pointer __p = __data;
         __data = __other.__data;
         __other.__data = __p;
     }
 
     _LIBCPP_INLINE_VISIBILITY span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept
     { return {reinterpret_cast<const byte *>(data()), size_bytes()}; }
 
-    _LIBCPP_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writeable_bytes() const noexcept
+    _LIBCPP_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept
     { return {reinterpret_cast<byte *>(data()), size_bytes()}; }
 
 private:
     pointer    __data;
 
 };
 
 
_LIBCPP_INLINE_VISIBILITY constexpr void swap(span &__other) noexcept
         index_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_writeable_bytes() const noexcept
+    _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;
 };
 
 //  tuple interface

 get(span<_Tp, _Size> __s) noexcept
 {
     static_assert( dynamic_extent != _Size, "std::get<> not supported for std::span<T, dynamic_extent>");
     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::span)");
     return __s[_Ip];
 }
 
 
-//  as_bytes & as_writeable_bytes
+//  as_bytes & as_writable_bytes
 template <class _Tp, size_t _Extent>
 _LIBCPP_INLINE_VISIBILITY
 auto as_bytes(span<_Tp, _Extent> __s) noexcept
 -> decltype(__s.__as_bytes())
 { return    __s.__as_bytes(); }
 
 template <class _Tp, size_t _Extent>
 _LIBCPP_INLINE_VISIBILITY
-auto as_writeable_bytes(span<_Tp, _Extent> __s) noexcept
--> enable_if_t<!is_const_v<_Tp>, decltype(__s.__as_writeable_bytes())>
-{ return __s.__as_writeable_bytes(); }
+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(); }
 
 template <class _Tp, size_t _Extent>
 _LIBCPP_INLINE_VISIBILITY
 constexpr void swap(span<_Tp, _Extent> &__lhs, span<_Tp, _Extent> &__rhs) noexcept
 { __lhs.swap(__rhs); }
 
 
 //  Deduction guides

libcxx/test/std/containers/views/span.objectrep/as_writable_bytes.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 <class ElementType, size_t Extent>
+//     span<byte,
+//          Extent == dynamic_extent
+//              ? dynamic_extent
+//              : sizeof(ElementType) * Extent>
+//     as_writable_bytes(span<ElementType, Extent> s) noexcept;
+
+
+#include <span>
+#include <cassert>
+#include <string>
+
+#include "test_macros.h"
+
+const int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
+
+struct A {};
+
+int main(int, char**)
+{
+    std::as_writable_bytes(std::span<const int>());            // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const long>());           // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const double>());         // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const A>());              // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const std::string>());    // expected-error {{no matching function for call to 'as_writable_bytes'}}
+
+    std::as_writable_bytes(std::span<const int, 0>());         // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const long, 0>());        // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const double, 0>());      // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const A, 0>());           // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const std::string, (size_t)0>()); // expected-error {{no matching function for call to 'as_writable_bytes'}}
+
+    std::as_writable_bytes(std::span<const int>   (iArr2, 1));     // expected-error {{no matching function for call to 'as_writable_bytes'}}
+    std::as_writable_bytes(std::span<const int, 1>(iArr2 + 5, 1)); // expected-error {{no matching function for call to 'as_writable_bytes'}}
+
+  return 0;
+}

libcxx/test/std/containers/views/span.objectrep/as_writable_bytes.pass.cpp

 
 // <span>
 
 // template <class ElementType, size_t Extent>
 //     span<byte,
 //          Extent == dynamic_extent
 //              ? dynamic_extent
 //              : sizeof(ElementType) * Extent>
-//     as_writeable_bytes(span<ElementType, Extent> s) noexcept;
+//     as_writable_bytes(span<ElementType, Extent> s) noexcept;
 
 
 #include <span>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 
 template<typename Span>
 void testRuntimeSpan(Span sp)
 {
-    ASSERT_NOEXCEPT(std::as_writeable_bytes(sp));
+    ASSERT_NOEXCEPT(std::as_writable_bytes(sp));
 
-    auto spBytes = std::as_writeable_bytes(sp);
+    auto spBytes = std::as_writable_bytes(sp);
     using SB = decltype(spBytes);
     ASSERT_SAME_TYPE(std::byte, typename SB::element_type);
 
     if (sp.extent == std::dynamic_extent)
         assert(spBytes.extent == std::dynamic_extent);
     else
         assert(spBytes.extent == sizeof(typename Span::element_type) * sp.extent);
 

libcxx/test/std/containers/views/span.objectrep/as_writeable_bytes.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 <class ElementType, size_t Extent>
-//     span<byte,
-//          Extent == dynamic_extent
-//              ? dynamic_extent
-//              : sizeof(ElementType) * Extent>
-//     as_writeable_bytes(span<ElementType, Extent> s) noexcept;
-
-
-#include <span>
-#include <cassert>
-#include <string>
-
-#include "test_macros.h"
-
-const int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
-
-struct A {};
-
-int main(int, char**)
-{
-    std::as_writeable_bytes(std::span<const int>());            // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const long>());           // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const double>());         // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const A>());              // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const std::string>());    // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-
-    std::as_writeable_bytes(std::span<const int, 0>());         // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const long, 0>());        // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const double, 0>());      // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const A, 0>());           // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const std::string, (size_t)0>()); // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-
-    std::as_writeable_bytes(std::span<const int>   (iArr2, 1));     // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-    std::as_writeable_bytes(std::span<const int, 1>(iArr2 + 5, 1)); // expected-error {{no matching function for call to 'as_writeable_bytes'}}
-
-  return 0;
-}