[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/trunk/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/trunk/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/trunk/test/std/containers/views/span.objectrep/as_writable_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>
+
+// 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"
+
+template<typename Span>
+void testRuntimeSpan(Span sp)
+{
+    ASSERT_NOEXCEPT(std::as_writable_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);
+
+    assert(static_cast<void*>(spBytes.data()) == static_cast<void*>(sp.data()));
+    assert(spBytes.size() == sp.size_bytes());
+}
+
+struct A{};
+int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
+
+int main(int, char**)
+{
+    testRuntimeSpan(std::span<int>        ());
+    testRuntimeSpan(std::span<long>       ());
+    testRuntimeSpan(std::span<double>     ());
+    testRuntimeSpan(std::span<A>          ());
+    testRuntimeSpan(std::span<std::string>());
+
+    testRuntimeSpan(std::span<int, 0>        ());
+    testRuntimeSpan(std::span<long, 0>       ());
+    testRuntimeSpan(std::span<double, 0>     ());
+    testRuntimeSpan(std::span<A, 0>          ());
+    testRuntimeSpan(std::span<std::string, 0>());
+
+    testRuntimeSpan(std::span<int>(iArr2, 1));
+    testRuntimeSpan(std::span<int>(iArr2, 2));
+    testRuntimeSpan(std::span<int>(iArr2, 3));
+    testRuntimeSpan(std::span<int>(iArr2, 4));
+    testRuntimeSpan(std::span<int>(iArr2, 5));
+
+    testRuntimeSpan(std::span<int, 1>(iArr2 + 5, 1));
+    testRuntimeSpan(std::span<int, 2>(iArr2 + 4, 2));
+    testRuntimeSpan(std::span<int, 3>(iArr2 + 3, 3));
+    testRuntimeSpan(std::span<int, 4>(iArr2 + 2, 4));
+    testRuntimeSpan(std::span<int, 5>(iArr2 + 1, 5));
+
+    std::string s;
+    testRuntimeSpan(std::span<std::string>(&s, (std::size_t) 0));
+    testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
+}

libcxx/trunk/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;
-}

libcxx/trunk/test/std/containers/views/span.objectrep/as_writeable_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>
-
-// 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"
-
-template<typename Span>
-void testRuntimeSpan(Span sp)
-{
-    ASSERT_NOEXCEPT(std::as_writeable_bytes(sp));
-
-    auto spBytes = std::as_writeable_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);
-
-    assert(static_cast<void*>(spBytes.data()) == static_cast<void*>(sp.data()));
-    assert(spBytes.size() == sp.size_bytes());
-}
-
-struct A{};
-int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
-
-int main(int, char**)
-{
-    testRuntimeSpan(std::span<int>        ());
-    testRuntimeSpan(std::span<long>       ());
-    testRuntimeSpan(std::span<double>     ());
-    testRuntimeSpan(std::span<A>          ());
-    testRuntimeSpan(std::span<std::string>());
-
-    testRuntimeSpan(std::span<int, 0>        ());
-    testRuntimeSpan(std::span<long, 0>       ());
-    testRuntimeSpan(std::span<double, 0>     ());
-    testRuntimeSpan(std::span<A, 0>          ());
-    testRuntimeSpan(std::span<std::string, 0>());
-
-    testRuntimeSpan(std::span<int>(iArr2, 1));
-    testRuntimeSpan(std::span<int>(iArr2, 2));
-    testRuntimeSpan(std::span<int>(iArr2, 3));
-    testRuntimeSpan(std::span<int>(iArr2, 4));
-    testRuntimeSpan(std::span<int>(iArr2, 5));
-
-    testRuntimeSpan(std::span<int, 1>(iArr2 + 5, 1));
-    testRuntimeSpan(std::span<int, 2>(iArr2 + 4, 2));
-    testRuntimeSpan(std::span<int, 3>(iArr2 + 3, 3));
-    testRuntimeSpan(std::span<int, 4>(iArr2 + 2, 4));
-    testRuntimeSpan(std::span<int, 5>(iArr2 + 1, 5));
-
-    std::string s;
-    testRuntimeSpan(std::span<std::string>(&s, (std::size_t) 0));
-    testRuntimeSpan(std::span<std::string>(&s, 1));
-
-  return 0;
-}