[libc++] Fix std::move algorithm with trivial move-only types

[ldionne]

Summary

As reported in https://reviews.llvm.org/D151953#4472195, the std::move
algorithm (and various other functions that relied on it) stopped working
after starting to use __constexpr_memmove in its implementation. This
patch fixes that and adds tests for various related algorithms and
functions that were not exercising trivial move-only types.

[ldionne]

(This doesn't fix anything yet, this only adds the regression tests. I'm meeting with @philnik in a few minutes and we can discuss what we think is the best way to address this)

[ldionne]

Add the solution we discussed with Nikolas.

[philnik]

libcxx/include/__string/constexpr_c_functions.h

183–186

Would it make sense to first try construction? Then we could use __constexpr_memmove for uninitialized_{copy, move} too.

202

Why do you bit_cast here? Also, could we add a __bit_cast instead of using builtins randomly in the code?

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp

54–55

Instead of moving all the code an indentation deeper, maybe move the braces an indentation higher? That would basically change this test to use two-space indentation instead of four spaces, like we do in new code. (or just clang-format the whole thing)

[ldionne]

Address clang-format comment.

[alexfh]

It looks like this fix will take some time to converge. Can we first return to green, please? The premerge checks succeeded on https://reviews.llvm.org/D154595

[ldionne]

In D154613#4479865, @alexfh wrote:

It looks like this fix will take some time to converge. Can we first return to green, please? The premerge checks succeeded on https://reviews.llvm.org/D154595

See https://reviews.llvm.org/D154595#4480304

libcxx/include/__string/constexpr_c_functions.h

183–186

I actually ran into issues doing this (I think it triggers some issues in older standard modes), plus the semantics of this function (as currently written) are to perform an assignment, so I think trying the assignment first makes sense. I'm definitely willing to investigate, but I'd like to do that in its own patch. Are you OK with that?

202

I bit_cast in order to avoid having to deal with _Tp and _Up in the assignment -- I want to deal with a single type over there.

Also, could we add a __bit_cast instead of using builtins randomly in the code?

Yes, I can do that.

Edit: I just tried introducing __bit_cast and using it, and it actually triggers some test failures in C++11 and C++14 mode:

In file included from libcxx/strings/c.strings/constexpr_memmove.pass.cpp:25:
In file included from include/c++/v1/__string/constexpr_c_functions.h:12:
include/c++/v1/__bit/bit_cast.h:36:10: error: call to deleted constructor of 'CopyConstructible'
  return __builtin_bit_cast(_ToType, __from);
         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/c++/v1/__string/constexpr_c_functions.h:212:71: note: in instantiation of function template specialization 'std::__bit_cast<CopyConstructible, CopyConstructible>' requested here
        std::__assign_trivially_copyable(__dest + (__count - 1), std::__bit_cast<_Tp>(__src[__count - 1]));
                                                                      ^
libcxx/strings/c.strings/constexpr_memmove.pass.cpp:91:23: note: in instantiation of function template specialization 'std::__constexpr_memmove<CopyConstructible, CopyConstructible, 0>' requested here
  Dest* result = std::__constexpr_memmove(dst, src, std::__element_count(3));
                      ^
libcxx/strings/c.strings/constexpr_memmove.pass.cpp:111:3: note: in instantiation of function template specialization 'test_user_defined_types<CopyConstructible, CopyConstructible>' requested here
  test_user_defined_types<CopyConstructible, CopyConstructible>();
  ^
libcxx/strings/c.strings/constexpr_memmove.pass.cpp:40:3: note: 'CopyConstructible' has been explicitly marked deleted here
  CopyConstructible(CopyConstructible&&)                 = delete;
  ^

I think this is because RVO isn't mandated before C++17 (IIRC?), and so we actually require a move constructor to return from __bit_cast for some of the funky types I use in the test. So it looks like I might need to keep using __builtin_bit_cast directly here (even though I agree with you it would make more sense to use some std::__bit_cast).

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp

54–55

I'll clang-format it, you're right the diff is actually smaller.

[ldionne]

Address comments

[philnik]

libcxx/include/__string/constexpr_c_functions.h

183–186

That's fine with me.

202

Ugh. Ok, I'd be fine with using __builtin_bit_cast for now and adding a TODO to investigate further. There has to be some way to fix this.

libcxx/test/libcxx/strings/c.strings/constexpr_memmove.pass.cpp

10

Why is this unsupported in C++03?

[ldionne]

libcxx/test/libcxx/strings/c.strings/constexpr_memmove.pass.cpp

10

Actually, for the same reason that __bit_cast won't work:

In file included from /c.strings/constexpr_memmove.pass.cpp:25:
include/c++/v1/__string/constexpr_c_functions.h:211:66: error: copying parameter of type 'CopyConstructible' invokes deleted constructor
        std::__assign_trivially_copyable(__dest + (__count - 1), __builtin_bit_cast(_Tp, __src[__count - 1]));
                                                                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/c.strings/constexpr_memmove.pass.cpp:92:23: note: in instantiation of function template specialization 'std::__constexpr_memmove<CopyConstructible, CopyConstructible, 0>' requested here
  Dest* result = std::__constexpr_memmove(dst, src, std::__element_count(3));
                      ^
/c.strings/constexpr_memmove.pass.cpp:112:3: note: in instantiation of function template specialization 'test_user_defined_types<CopyConstructible, CopyConstructible>' requested here
  test_user_defined_types<CopyConstructible, CopyConstructible>();
  ^
/c.strings/constexpr_memmove.pass.cpp:41:3: note: 'CopyConstructible' has been explicitly marked deleted here
  CopyConstructible(CopyConstructible&&)                 = delete;
  ^

[ldionne]

libcxx/include/__string/constexpr_c_functions.h

202

In the next revision, I am actually removing __builtin_bit_cast entirely so this is moot.

libcxx/test/libcxx/strings/c.strings/constexpr_memmove.pass.cpp

10

In the next update, I'm dropping __builtin_bit_cast and this test now works in C++03.

[ldionne]

Drop bit_cast, add tests. This should fix CI.

[philnik]

LGTM with a comment.

libcxx/include/__string/constexpr_c_functions.h

171

Could you add a comment here explaining that we implicitly end the lifetime of the old object and then start the lifetime of the new object? I think this is a quite obscure part of the standard.

179

Having if constexpr would make this so much nicer :(

[ldionne]

Fix clang-format.

[ldionne]

libcxx/include/__string/constexpr_c_functions.h

171

A program is not required to call the destructor of an object to end its lifetime if the object is trivially-destructible (be careful that the correct behavior of the program may depend on the destructor).

From https://en.cppreference.com/w/cpp/language/lifetime (under storage reuse). Comment added x2.

[ldionne]

Address comments, fix CI, rebase.

libcxx/include/__string/constexpr_c_functions.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___STRING_CONSTEXPR_C_FUNCTIONS_H
 #define _LIBCPP___STRING_CONSTEXPR_C_FUNCTIONS_H
 
 #include <__config>
+#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
 #include <__type_traits/datasizeof.h>
 #include <__type_traits/is_always_bitcastable.h>
+#include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_equality_comparable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/is_trivially_lexicographically_comparable.h>
 #include <__type_traits/remove_cv.h>
 #include <__utility/is_pointer_in_range.h>
 #include <cstddef>
 
#endif
     return nullptr;
   } else {
     char __value_buffer = 0;
     __builtin_memcpy(&__value_buffer, &__value, sizeof(char));
     return static_cast<_Tp*>(__builtin_memchr(__str, __value_buffer, __count));
   }
 }
 
+// This function performs an assignment to an existing, already alive TriviallyCopyable object
+// from another TriviallyCopyable object.
+//
+// It basically works around the fact that TriviallyCopyable objects are not required to be
+// syntactically copy/move constructible or copy/move assignable. Technically, only one of the
+// four operations is required to be syntactically valid -- but at least one definitely has to
+// be valid.
+//
+// This is necessary in order to implement __constexpr_memmove below in a way that mirrors as
+// closely as possible what the compiler's __builtin_memmove is able to do.
+template <class _Tp, class _Up, __enable_if_t<is_assignable<_Tp&, _Up const&>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp& __assign_trivially_copyable(_Tp& __dest, _Up const& __src) {
+  __dest = __src;
+  return __dest;
+}
+
+// clang-format off
+template <class _Tp, class _Up, __enable_if_t<!is_assignable<_Tp&, _Up const&>::value &&
+                                               is_assignable<_Tp&, _Up&&>::value, int> = 0>
+// clang-format on
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp& __assign_trivially_copyable(_Tp& __dest, _Up& __src) {
+  __dest =
+      static_cast<_Up&&>(__src); // this is safe, we're not actually moving anything since the assignment is trivial
+  return __dest;
+}
+
+// clang-format off
+template <class _Tp, class _Up, __enable_if_t<!is_assignable<_Tp&, _Up const&>::value &&
+                                              !is_assignable<_Tp&, _Up&&>::value &&
+                                               is_constructible<_Tp, _Up const&>::value, int> = 0>
+// clang-format on
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& __assign_trivially_copyable(_Tp& __dest, _Up const& __src) {
+  std::__construct_at(std::addressof(__dest), __src);
+  return __dest;
+}
+
+// clang-format off
+template <class _Tp, class _Up, __enable_if_t<!is_assignable<_Tp&, _Up const&>::value &&
+                                              !is_assignable<_Tp&, _Up&&>::value &&
+                                              !is_constructible<_Tp, _Up const&>::value &&
+                                               is_constructible<_Tp, _Up&&>::value, int> = 0>
+// clang-format on
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& __assign_trivially_copyable(_Tp& __dest, _Up& __src) {
+  std::__construct_at(
+      std::addressof(__dest),
+      static_cast<_Up&&>(__src)); // this is safe, we're not actually moving anything since the constructor is trivial
+  return __dest;
+}
+
 template <class _Tp, class _Up, __enable_if_t<__is_always_bitcastable<_Up, _Tp>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp*
 __constexpr_memmove(_Tp* __dest, _Up* __src, __element_count __n) {
   size_t __count = static_cast<size_t>(__n);
   if (__libcpp_is_constant_evaluated()) {
 #ifdef _LIBCPP_COMPILER_CLANG_BASED
     if (is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >::value) {
       ::__builtin_memmove(__dest, __src, __count * sizeof(_Tp));
       return __dest;
     }
 #endif
     if (std::__is_pointer_in_range(__src, __src + __count, __dest)) {
       for (; __count > 0; --__count)
-        __dest[__count - 1] = __src[__count - 1];
+        std::__assign_trivially_copyable(__dest[__count - 1], __src[__count - 1]);
     } else {
       for (size_t __i = 0; __i != __count; ++__i)
-        __dest[__i] = __src[__i];
+        std::__assign_trivially_copyable(__dest[__i], __src[__i]);
     }
   } else if (__count > 0) {
     ::__builtin_memmove(__dest, __src, (__count - 1) * sizeof(_Tp) + __libcpp_datasizeof<_Tp>::value);
   }
   return __dest;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___STRING_CONSTEXPR_C_FUNCTIONS_H

libcxx/test/libcxx/strings/c.strings/constexpr_memmove.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// ADDITIONAL_COMPILE_FLAGS: -Wno-private-header
+
+// _Tp* __constexpr_memmove(_Tp* __dest, _Up* __src, __element_count __n);
+//
+// General tests for __constexpr_memmove.
+//
+// In particular, we try to ensure that __constexpr_memmove behaves like
+// __builtin_memmove as closely as possible. This means that it produces the
+// same effect, but also that it has the same type requirements.
+//
+// __builtin_memmove only requires that the types are TriviallyCopyable
+// (which is interestingly different from both is_trivially_XXX_constructible
+// and is_trivially_XXX_assignable), so we use some funky types to test these
+// corner cases.
+
+#include <__string/constexpr_c_functions.h>
+#include <cassert>
+#include <cstdint>
+#include <type_traits>
+
+#include "test_macros.h"
+
+// The following types are all TriviallyCopyable, but they are not all
+// trivially_{copy,move}_{constructible,assignable}. TriviallyCopyable
+// guarantees that the type is *at least* one of the four, but no more
+// than that.
+struct CopyConstructible {
+  CopyConstructible() = default;
+  int value = 0;
+
+  CopyConstructible(const CopyConstructible&)            = default;
+  CopyConstructible(CopyConstructible&&)                 = delete;
+  CopyConstructible& operator=(const CopyConstructible&) = delete;
+  CopyConstructible& operator=(CopyConstructible&&)      = delete;
+};
+
+struct MoveConstructible {
+  MoveConstructible() = default;
+  int value = 0;
+
+  MoveConstructible(const MoveConstructible&)            = delete;
+  MoveConstructible(MoveConstructible&&)                 = default;
+  MoveConstructible& operator=(const MoveConstructible&) = delete;
+  MoveConstructible& operator=(MoveConstructible&&)      = delete;
+};
+
+struct CopyAssignable {
+  CopyAssignable() = default;
+  int value = 0;
+
+  CopyAssignable(const CopyAssignable&)            = delete;
+  CopyAssignable(CopyAssignable&&)                 = delete;
+  CopyAssignable& operator=(const CopyAssignable&) = default;
+  CopyAssignable& operator=(CopyAssignable&&)      = delete;
+};
+
+struct MoveAssignable {
+  MoveAssignable() = default;
+  int value = 0;
+
+  MoveAssignable(const MoveAssignable&)            = delete;
+  MoveAssignable(MoveAssignable&&)                 = delete;
+  MoveAssignable& operator=(const MoveAssignable&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&)      = default;
+};
+
+template <class Source, class Dest>
+TEST_CONSTEXPR_CXX14 void test_user_defined_types() {
+  static_assert(std::is_trivially_copyable<Source>::value, "test the test");
+  static_assert(std::is_trivially_copyable<Dest>::value, "test the test");
+
+  // Note that we can't just initialize with an initializer list since some of the types we use here
+  // are not copy-constructible, which is required in pre-C++20 Standards for that syntax to work.
+  Source src[3];
+  src[0].value = 1;
+  src[1].value = 2;
+  src[2].value = 3;
+  Dest dst[3];
+  dst[0].value = 111;
+  dst[1].value = 111;
+  dst[2].value = 111;
+
+  Dest* result = std::__constexpr_memmove(dst, src, std::__element_count(3));
+  assert(result == dst);
+  assert(dst[0].value == 1);
+  assert(dst[1].value == 2);
+  assert(dst[2].value == 3);
+}
+
+template <class Source, class Dest>
+TEST_CONSTEXPR_CXX14 void test_builtin_types() {
+  Source src[3] = {1, 2, 3};
+  Dest dst[3] = {111, 111, 111};
+
+  Dest* result = std::__constexpr_memmove(dst, src, std::__element_count(3));
+  assert(result == dst);
+  assert(dst[0] == 1);
+  assert(dst[1] == 2);
+  assert(dst[2] == 3);
+}
+
+template <class SourcePtr, class DestPtr, class ObjectType>
+TEST_CONSTEXPR_CXX14 void test_pointer_types() {
+  ObjectType objs[3] = {1, 2, 3};
+
+  SourcePtr src[3] = {objs + 0, objs + 1, objs + 2};
+  DestPtr dst[3] = {nullptr, nullptr, nullptr};
+
+  DestPtr* result = std::__constexpr_memmove(dst, src, std::__element_count(3));
+  assert(result == dst);
+  assert(dst[0] == objs + 0);
+  assert(dst[1] == objs + 1);
+  assert(dst[2] == objs + 2);
+}
+
+TEST_CONSTEXPR_CXX14 bool test() {
+  test_user_defined_types<CopyConstructible, CopyConstructible>();
+  test_user_defined_types<MoveConstructible, MoveConstructible>();
+  test_user_defined_types<CopyAssignable, CopyAssignable>();
+  test_user_defined_types<MoveAssignable, MoveAssignable>();
+
+  test_builtin_types<char, char>();
+  test_builtin_types<short, short>();
+  test_builtin_types<int, int>();
+  test_builtin_types<long, long>();
+  test_builtin_types<long long, long long>();
+
+  // Cross-type
+  test_builtin_types<std::int16_t, std::uint16_t>();
+  test_builtin_types<std::int16_t, char16_t>();
+  test_builtin_types<std::int32_t, std::uint32_t>();
+  test_builtin_types<std::int32_t, char32_t>();
+
+  test_pointer_types<char*, char*, char>();
+  test_pointer_types<int*, int*, int>();
+  test_pointer_types<long*, long*, long>();
+  test_pointer_types<void*, void*, int>();
+  test_pointer_types<int* const, int*, int>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 14
+  static_assert(test(), "");
+#endif
+  return 0;
+}

libcxx/test/libcxx/transitive_includes/cxx03.csv

 array compare
 array concepts
 array cstddef
 array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
+array new
 array stdexcept
 array type_traits
 array utility
 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint

 charconv concepts
 charconv cstddef
 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
+charconv new
 charconv type_traits
 chrono bit
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono cstring

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
+format new
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list
 queue limits
+queue new
 queue type_traits
 queue vector
 queue version
 random algorithm
 random climits
 random cmath
 random concepts
 random cstddef

 sstream version
 stack compare
 stack concepts
 stack cstddef
 stack deque
 stack functional
 stack initializer_list
 stack limits
+stack new
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint

 string_view cstdio
 string_view cstdlib
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view iterator
 string_view limits
+string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare

libcxx/test/libcxx/transitive_includes/cxx11.csv

 array compare
 array concepts
 array cstddef
 array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
+array new
 array stdexcept
 array type_traits
 array utility
 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint

 charconv concepts
 charconv cstddef
 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
+charconv new
 charconv type_traits
 chrono bit
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono cstring

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
+format new
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list
 queue limits
+queue new
 queue type_traits
 queue vector
 queue version
 random algorithm
 random climits
 random cmath
 random concepts
 random cstddef

 sstream version
 stack compare
 stack concepts
 stack cstddef
 stack deque
 stack functional
 stack initializer_list
 stack limits
+stack new
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint

 string_view cstdio
 string_view cstdlib
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view iterator
 string_view limits
+string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare

libcxx/test/libcxx/transitive_includes/cxx14.csv

 array compare
 array concepts
 array cstddef
 array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
+array new
 array stdexcept
 array type_traits
 array utility
 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint

 charconv concepts
 charconv cstddef
 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
+charconv new
 charconv type_traits
 chrono bit
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono cstring

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
+format new
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list
 queue limits
+queue new
 queue type_traits
 queue vector
 queue version
 random algorithm
 random climits
 random cmath
 random concepts
 random cstddef

 sstream version
 stack compare
 stack concepts
 stack cstddef
 stack deque
 stack functional
 stack initializer_list
 stack limits
+stack new
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint

 string_view cstdio
 string_view cstdlib
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view iterator
 string_view limits
+string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare

libcxx/test/libcxx/transitive_includes/cxx17.csv

 array compare
 array concepts
 array cstddef
 array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
+array new
 array stdexcept
 array type_traits
 array utility
 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint

 charconv concepts
 charconv cstddef
 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
+charconv new
 charconv type_traits
 chrono bit
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono cstring

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
+format new
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list
 queue limits
+queue new
 queue type_traits
 queue vector
 queue version
 random algorithm
 random climits
 random cmath
 random concepts
 random cstddef

 sstream version
 stack compare
 stack concepts
 stack cstddef
 stack deque
 stack functional
 stack initializer_list
 stack limits
+stack new
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint

 string_view cstdio
 string_view cstdlib
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view iterator
 string_view limits
+string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare

libcxx/test/libcxx/transitive_includes/cxx20.csv

 array compare
 array concepts
 array cstddef
 array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
+array new
 array stdexcept
 array type_traits
 array utility
 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint

 charconv concepts
 charconv cstddef
 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
+charconv new
 charconv type_traits
 chrono array
 chrono bit
 chrono charconv
 chrono cmath
 chrono compare
 chrono concepts
 chrono cstddef

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
+format new
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list
 queue limits
+queue new
 queue type_traits
 queue vector
 queue version
 random algorithm
 random climits
 random cmath
 random concepts
 random cstddef

 sstream version
 stack compare
 stack concepts
 stack cstddef
 stack deque
 stack functional
 stack initializer_list
 stack limits
+stack new
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint

 string_view cstdio
 string_view cstdlib
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view iterator
 string_view limits
+string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare

libcxx/test/libcxx/transitive_includes/cxx23.csv

 any new
 any typeinfo
 any version
 array compare
 array cstddef
 array cstdint
 array initializer_list
 array limits
+array new
 array stdexcept
 array version
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
 atomic iosfwd

 bitset version
 ccomplex complex
 charconv cerrno
 charconv cmath
 charconv cstddef
 charconv cstdint
 charconv initializer_list
 charconv limits
+charconv new
 chrono array
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono ctime
 chrono initializer_list

 ostream typeinfo
 ostream version
 queue compare
 queue cstddef
 queue cstdint
 queue deque
 queue initializer_list
 queue limits
+queue new
 queue vector
 queue version
 random cmath
 random cstddef
 random cstdint
 random initializer_list
 random iosfwd
 random limits
 random numeric
 random string
 random vector
 random version
 ranges compare
 ranges cstddef
 ranges cwchar
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
-ranges new
 ranges optional
 ranges span
 ranges tuple
 ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio version

 sstream string
 sstream version
 stack compare
 stack cstddef
 stack cstdint
 stack deque
 stack initializer_list
 stack limits
+stack new
 stack version
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version

 string_view cstddef
 string_view cstdint
 string_view cstdio
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view limits
+string_view new
 string_view stdexcept
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare
 system_error cstddef

libcxx/test/libcxx/transitive_includes/cxx26.csv

 any new
 any typeinfo
 any version
 array compare
 array cstddef
 array cstdint
 array initializer_list
 array limits
+array new
 array stdexcept
 array version
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
 atomic iosfwd

 bitset version
 ccomplex complex
 charconv cerrno
 charconv cmath
 charconv cstddef
 charconv cstdint
 charconv initializer_list
 charconv limits
+charconv new
 chrono array
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono ctime
 chrono initializer_list

 ostream typeinfo
 ostream version
 queue compare
 queue cstddef
 queue cstdint
 queue deque
 queue initializer_list
 queue limits
+queue new
 queue vector
 queue version
 random cmath
 random cstddef
 random cstdint
 random initializer_list
 random iosfwd
 random limits
 random numeric
 random string
 random vector
 random version
 ranges compare
 ranges cstddef
 ranges cwchar
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
-ranges new
 ranges optional
 ranges span
 ranges tuple
 ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio version

 sstream string
 sstream version
 stack compare
 stack cstddef
 stack cstdint
 stack deque
 stack initializer_list
 stack limits
+stack new
 stack version
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version

 string_view cstddef
 string_view cstdint
 string_view cstdio
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view limits
+string_view new
 string_view stdexcept
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare
 system_error cstddef

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

 
 // template<InputIterator InIter, typename OutIter>
 //   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type>
 //   OutIter
 //   move(InIter first, InIter last, OutIter result);
 
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <memory>
 
-#include "test_macros.h"
+#include "MoveOnly.h"
 #include "test_iterators.h"
+#include "test_macros.h"
 
 class PaddedBase {
 public:
   TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
 
   std::int16_t a_;
   std::int8_t b_;
 };
TEST_CONSTEXPR_CXX20 bool test() {
 
   { // Make sure that overlapping ranges can be copied
     int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     std::move(a + 3, a + 10, a);
     int expected[] = {4, 5, 6, 7, 8, 9, 10, 8, 9, 10};
     assert(std::equal(a, a + 10, expected));
   }
 
+  // Make sure that the algorithm works with move-only types
+  {
+    // When non-trivial
+    {
+      MoveOnly from[3] = {1, 2, 3};
+      MoveOnly to[3] = {};
+      std::move(std::begin(from), std::end(from), std::begin(to));
+      assert(to[0] == MoveOnly(1));
+      assert(to[1] == MoveOnly(2));
+      assert(to[2] == MoveOnly(3));
+    }
+    // When trivial
+    {
+      TrivialMoveOnly from[3] = {1, 2, 3};
+      TrivialMoveOnly to[3] = {};
+      std::move(std::begin(from), std::end(from), std::begin(to));
+      assert(to[0] == TrivialMoveOnly(1));
+      assert(to[1] == TrivialMoveOnly(2));
+      assert(to[2] == TrivialMoveOnly(3));
+    }
+  }
+
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER >= 20
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp

 
 // template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
 //   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type>
 //   OutIter
 //   move_backward(InIter first, InIter last, OutIter result);
 
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <memory>
 
-#include "test_macros.h"
+#include "MoveOnly.h"
 #include "test_iterators.h"
+#include "test_macros.h"
 
 class PaddedBase {
 public:
   TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
 
   std::int16_t a_;
   std::int8_t b_;
 };
TEST_CONSTEXPR_CXX20 bool test() {
 
   { // Make sure that overlapping ranges can be copied
     int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     std::move_backward(a, a + 7, a + 10);
     int expected[] = {1, 2, 3, 1, 2, 3, 4, 5, 6, 7};
     assert(std::equal(a, a + 10, expected));
   }
 
+  // Make sure that the algorithm works with move-only types
+  {
+    // When non-trivial
+    {
+      MoveOnly from[3] = {1, 2, 3};
+      MoveOnly to[3] = {};
+      std::move_backward(std::begin(from), std::end(from), std::end(to));
+      assert(to[0] == MoveOnly(1));
+      assert(to[1] == MoveOnly(2));
+      assert(to[2] == MoveOnly(3));
+    }
+    // When trivial
+    {
+      TrivialMoveOnly from[3] = {1, 2, 3};
+      TrivialMoveOnly to[3] = {};
+      std::move_backward(std::begin(from), std::end(from), std::end(to));
+      assert(to[0] == TrivialMoveOnly(1));
+      assert(to[1] == TrivialMoveOnly(2));
+      assert(to[2] == TrivialMoveOnly(3));
+    }
+  }
+
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER >= 20
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp

 //   requires indirectly_movable<iterator_t<R>, O>
 //   constexpr ranges::move_result<borrowed_iterator_t<R>, O>
 //     ranges::move(R&& r, O result);
 
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <deque>
+#include <iterator>
 #include <ranges>
 #include <vector>
 
 #include "almost_satisfies_types.h"
 #include "MoveOnly.h"
 #include "test_iterators.h"
 
 template <class In, class Out = In, class Sent = sentinel_wrapper<In>>
constexpr bool test() {
   test_proxy_in_iterators<Cpp20InputProxyIterator>();
   test_proxy_in_iterators<ForwardProxyIterator>();
   test_proxy_in_iterators<BidirectionalProxyIterator>();
   test_proxy_in_iterators<RandomAccessProxyIterator>();
   test_proxy_in_iterators<ContiguousProxyIterator>();
   test_proxy_in_iterators<ProxyIterator>();
 
   { // check that a move-only type works
+    // When non-trivial
     {
       MoveOnly a[] = {1, 2, 3};
       MoveOnly b[3];
       std::ranges::move(a, std::begin(b));
       assert(b[0].get() == 1);
       assert(b[1].get() == 2);
       assert(b[2].get() == 3);
     }
     {
       MoveOnly a[] = {1, 2, 3};
       MoveOnly b[3];
       std::ranges::move(std::begin(a), std::end(a), std::begin(b));
       assert(b[0].get() == 1);
       assert(b[1].get() == 2);
       assert(b[2].get() == 3);
     }
+
+    // When trivial
+    {
+      TrivialMoveOnly a[] = {1, 2, 3};
+      TrivialMoveOnly b[3];
+      std::ranges::move(a, std::begin(b));
+      assert(b[0].get() == 1);
+      assert(b[1].get() == 2);
+      assert(b[2].get() == 3);
+    }
+    {
+      TrivialMoveOnly a[] = {1, 2, 3};
+      TrivialMoveOnly b[3];
+      std::ranges::move(std::begin(a), std::end(a), std::begin(b));
+      assert(b[0].get() == 1);
+      assert(b[1].get() == 2);
+      assert(b[2].get() == 3);
+    }
   }
 
   { // check that a move-only type works for ProxyIterator
     {
       MoveOnly a[] = {1, 2, 3};
       MoveOnly b[3];
       ProxyRange proxyA{a};
       ProxyRange proxyB{b};

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp

 //   requires indirectly_movable<iterator_t<R>, I>
 //   constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
 //     ranges::move_backward(R&& r, I result);
 
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <deque>
+#include <iterator>
 #include <ranges>
 #include <vector>
 
 #include "almost_satisfies_types.h"
 #include "MoveOnly.h"
 #include "test_iterators.h"
 
 template <class In, class Out = In, class Sent = sentinel_wrapper<In>>
constexpr bool test() {
   test_in_iterators<std::type_identity_t>();
 
   test_proxy_in_iterators<BidirectionalProxyIterator>();
   test_proxy_in_iterators<RandomAccessProxyIterator>();
   test_proxy_in_iterators<ContiguousProxyIterator>();
   test_proxy_in_iterators<ProxyIterator>();
 
   { // check that a move-only type works
+    // When non-trivial
     {
       MoveOnly a[] = {1, 2, 3};
       MoveOnly b[3];
       std::ranges::move_backward(a, std::end(b));
       assert(b[0].get() == 1);
       assert(b[1].get() == 2);
       assert(b[2].get() == 3);
     }
     {
       MoveOnly a[] = {1, 2, 3};
       MoveOnly b[3];
       std::ranges::move_backward(std::begin(a), std::end(a), std::end(b));
       assert(b[0].get() == 1);
       assert(b[1].get() == 2);
       assert(b[2].get() == 3);
     }
+
+    // When trivial
+    {
+      TrivialMoveOnly a[] = {1, 2, 3};
+      TrivialMoveOnly b[3];
+      std::ranges::move_backward(a, std::end(b));
+      assert(b[0].get() == 1);
+      assert(b[1].get() == 2);
+      assert(b[2].get() == 3);
+    }
+    {
+      TrivialMoveOnly a[] = {1, 2, 3};
+      TrivialMoveOnly b[3];
+      std::ranges::move_backward(std::begin(a), std::end(a), std::end(b));
+      assert(b[0].get() == 1);
+      assert(b[1].get() == 2);
+      assert(b[2].get() == 3);
+    }
   }
 
   { // check that a move-only type works for ProxyIterator
     {
       MoveOnly a[] = {1, 2, 3};
       MoveOnly b[3];
       ProxyRange proxyA{a};
       ProxyRange proxyB{b};

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // iterator erase(const_iterator position);
 
 #include <vector>
 #include <iterator>
 #include <cassert>
 
-#include "test_macros.h"
-#include "min_allocator.h"
 #include "asan_testing.h"
+#include "min_allocator.h"
+#include "MoveOnly.h"
+#include "test_macros.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct Throws {
-    Throws() : v_(0) {}
-    Throws(int v) : v_(v) {}
-    Throws(const Throws  &rhs) : v_(rhs.v_) { if (sThrows) throw 1; }
-    Throws(      Throws &&rhs) : v_(rhs.v_) { if (sThrows) throw 1; }
-    Throws& operator=(const Throws  &rhs) { v_ = rhs.v_; return *this; }
-    Throws& operator=(      Throws &&rhs) { v_ = rhs.v_; return *this; }
-    int v_;
-    static bool sThrows;
-    };
+  Throws(const Throws& rhs) : v_(rhs.v_) {
+    if (sThrows)
+      throw 1;
+  }
+  Throws(Throws&& rhs) : v_(rhs.v_) {
+    if (sThrows)
+      throw 1;
+  }
+  Throws& operator=(const Throws& rhs) {
+    v_ = rhs.v_;
+    return *this;
+  }
+  Throws& operator=(Throws&& rhs) {
+    v_ = rhs.v_;
+    return *this;
+  }
 
 bool Throws::sThrows = false;
 #endif
 
-TEST_CONSTEXPR_CXX20 bool tests()
-{
-    {
+TEST_CONSTEXPR_CXX20 bool tests() {
     int a1[] = {1, 2, 3, 4, 5};
-    std::vector<int> l1(a1, a1+5);
+    std::vector<int> l1(a1, a1 + 5);
     l1.erase(l1.begin());
     assert(is_contiguous_container_asan_correct(l1));
-    assert(l1 == std::vector<int>(a1+1, a1+5));
-    }
-    {
+    assert(l1 == std::vector<int>(a1 + 1, a1 + 5));
     int a1[] = {1, 2, 3, 4, 5};
     int e1[] = {1, 3, 4, 5};
-    std::vector<int> l1(a1, a1+5);
+    std::vector<int> l1(a1, a1 + 5);
     l1.erase(l1.begin() + 1);
     assert(is_contiguous_container_asan_correct(l1));
-    assert(l1 == std::vector<int>(e1, e1+4));
-    }
-    {
+    assert(l1 == std::vector<int>(e1, e1 + 4));
     int a1[] = {1, 2, 3};
-    std::vector<int> l1(a1, a1+3);
+    std::vector<int> l1(a1, a1 + 3);
     std::vector<int>::const_iterator i = l1.begin();
     assert(is_contiguous_container_asan_correct(l1));
     ++i;
     std::vector<int>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
     assert(std::distance(l1.begin(), l1.end()) == 2);
     assert(*j == 3);
     assert(*l1.begin() == 1);
     assert(*std::next(l1.begin()) == 3);
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
     assert(std::distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == 1);
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
     assert(std::distance(l1.begin(), l1.end()) == 0);
     assert(is_contiguous_container_asan_correct(l1));
-    }
+
+  // Make sure vector::erase works with move-only types
+  // When non-trivial
+  {
+    std::vector<MoveOnly> v;
+    v.emplace_back(1);
+    v.emplace_back(2);
+    v.emplace_back(3);
+    v.erase(v.begin());
+    assert(v.size() == 2);
+    assert(v[0] == MoveOnly(2));
+    assert(v[1] == MoveOnly(3));
+  }
+  // When trivial
+  {
+    std::vector<TrivialMoveOnly> v;
+    v.emplace_back(1);
+    v.emplace_back(2);
+    v.emplace_back(3);
+    v.erase(v.begin());
+    assert(v.size() == 2);
+    assert(v[0] == TrivialMoveOnly(2));
+    assert(v[1] == TrivialMoveOnly(3));
+  }
+
 #if TEST_STD_VER >= 11
-    {
     int a1[] = {1, 2, 3};
-    std::vector<int, min_allocator<int>> l1(a1, a1+3);
+    std::vector<int, min_allocator<int>> l1(a1, a1 + 3);
     std::vector<int, min_allocator<int>>::const_iterator i = l1.begin();
     assert(is_contiguous_container_asan_correct(l1));
     ++i;
     std::vector<int, min_allocator<int>>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
     assert(std::distance(l1.begin(), l1.end()) == 2);
     assert(*j == 3);
     assert(*l1.begin() == 1);
     assert(*std::next(l1.begin()) == 3);
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
     assert(std::distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == 1);
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
     assert(std::distance(l1.begin(), l1.end()) == 0);
     assert(is_contiguous_container_asan_correct(l1));
-    }
 #endif
 
-    return true;
 }
 
-int main(int, char**)
-{
-    tests();
+int main(int, char**) {
 #if TEST_STD_VER > 17
-    static_assert(tests());
 #endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   // Test for LWG2853:
   // Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
-    {
-        Throws arr[] = {1, 2, 3};
-        std::vector<Throws> v(arr, arr+3);
-        Throws::sThrows = true;
-        v.erase(v.begin());
-        v.erase(--v.end());
-        v.erase(v.begin());
-        assert(v.size() == 0);
-    }
+    std::vector<Throws> v(arr, arr + 3);
 #endif
 
-    return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // iterator erase(const_iterator first, const_iterator last);
 
 #include <vector>
 #include <iterator>
 #include <cassert>
 
-#include "test_macros.h"
-#include "min_allocator.h"
 #include "asan_testing.h"
+#include "min_allocator.h"
+#include "MoveOnly.h"
+#include "test_macros.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct Throws {
     Throws() : v_(0) {}
     Throws(int v) : v_(v) {}
     Throws(const Throws  &rhs) : v_(rhs.v_) { if (sThrows) throw 1; }
     Throws(      Throws &&rhs) : v_(rhs.v_) { if (sThrows) throw 1; }
     Throws& operator=(const Throws  &rhs) { v_ = rhs.v_; return *this; }
int a1[] = {1, 2, 3};
         outer.erase(outer.begin(), outer.begin());
         assert(outer.size() == 2);
         assert(outer[0].size() == 1);
         assert(outer[1].size() == 1);
         assert(is_contiguous_container_asan_correct(outer));
         assert(is_contiguous_container_asan_correct(outer[0]));
         assert(is_contiguous_container_asan_correct(outer[1]));
     }
+    // Make sure vector::erase works with move-only types
+    {
+        // When non-trivial
+        {
+            std::vector<MoveOnly> v;
+            v.emplace_back(1); v.emplace_back(2); v.emplace_back(3);
+            v.erase(v.begin(), v.begin() + 2);
+            assert(v.size() == 1);
+            assert(v[0] == MoveOnly(3));
+        }
+        // When trivial
+        {
+            std::vector<TrivialMoveOnly> v;
+            v.emplace_back(1); v.emplace_back(2); v.emplace_back(3);
+            v.erase(v.begin(), v.begin() + 2);
+            assert(v.size() == 1);
+            assert(v[0] == TrivialMoveOnly(3));
+        }
+    }
 #if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
         assert(std::distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());

libcxx/test/support/MoveOnly.h

#if TEST_STD_VER > 17
     friend constexpr auto operator<=>(const MoveOnly&, const MoveOnly&) = default;
 #endif // TEST_STD_VER > 17
 
     TEST_CONSTEXPR_CXX14 MoveOnly operator+(const MoveOnly& x) const
         { return MoveOnly(data_ + x.data_); }
     TEST_CONSTEXPR_CXX14 MoveOnly operator*(const MoveOnly& x) const
         { return MoveOnly(data_ * x.data_); }
 
-    template<class T, class U>
-    friend void operator,(T t, U u) = delete;
-};
+    template<class T>
+    friend void operator,(MoveOnly const&, T) = delete;
 
+    template<class T>
+    friend void operator,(T, MoveOnly const&) = delete;
+};
 
 template <>
 struct std::hash<MoveOnly>
 {
     typedef MoveOnly argument_type;
     typedef std::size_t result_type;
     TEST_CONSTEXPR std::size_t operator()(const MoveOnly& x) const {return static_cast<size_t>(x.get());}
 };
 
+class TrivialMoveOnly {
+    int data_;
+
+  public:
+    TEST_CONSTEXPR TrivialMoveOnly(int data = 1) : data_(data) {}
+
+    TrivialMoveOnly(const TrivialMoveOnly&)            = delete;
+    TrivialMoveOnly& operator=(const TrivialMoveOnly&) = delete;
+
+    TrivialMoveOnly(TrivialMoveOnly&&)            = default;
+    TrivialMoveOnly& operator=(TrivialMoveOnly&&) = default;
+
+    TEST_CONSTEXPR int get() const { return data_; }
+
+    friend TEST_CONSTEXPR bool operator==(const TrivialMoveOnly& x, const TrivialMoveOnly& y) {
+      return x.data_ == y.data_;
+    }
+    friend TEST_CONSTEXPR bool operator!=(const TrivialMoveOnly& x, const TrivialMoveOnly& y) {
+      return x.data_ != y.data_;
+    }
+    friend TEST_CONSTEXPR bool operator<(const TrivialMoveOnly& x, const TrivialMoveOnly& y) {
+      return x.data_ < y.data_;
+    }
+    friend TEST_CONSTEXPR bool operator<=(const TrivialMoveOnly& x, const TrivialMoveOnly& y) {
+      return x.data_ <= y.data_;
+    }
+    friend TEST_CONSTEXPR bool operator>(const TrivialMoveOnly& x, const TrivialMoveOnly& y) {
+      return x.data_ > y.data_;
+    }
+    friend TEST_CONSTEXPR bool operator>=(const TrivialMoveOnly& x, const TrivialMoveOnly& y) {
+      return x.data_ >= y.data_;
+    }
+
+#if TEST_STD_VER > 17
+    friend constexpr auto operator<=>(const TrivialMoveOnly&, const TrivialMoveOnly&) = default;
+#endif // TEST_STD_VER > 17
+
+    TEST_CONSTEXPR_CXX14 TrivialMoveOnly operator+(const TrivialMoveOnly& x) const {
+      return TrivialMoveOnly(data_ + x.data_);
+    }
+    TEST_CONSTEXPR_CXX14 TrivialMoveOnly operator*(const TrivialMoveOnly& x) const {
+      return TrivialMoveOnly(data_ * x.data_);
+    }
+
+    template<class T>
+    friend void operator,(TrivialMoveOnly const&, T) = delete;
+
+    template<class T>
+    friend void operator,(T, TrivialMoveOnly const&) = delete;
+};
+
+template <>
+struct std::hash<TrivialMoveOnly> {
+    typedef TrivialMoveOnly argument_type;
+    typedef std::size_t result_type;
+    TEST_CONSTEXPR std::size_t operator()(const TrivialMoveOnly& x) const { return static_cast<size_t>(x.get()); }
+};
+
 #endif // MOVEONLY_H