Adjust is_replaceable to disregard self-move

Author: ldionne

libcxx/include/__exception/exception_ptr.h

@@ -66,10 +66,9 @@ class _LIBCPP_EXPORTED_FROM_ABI exception_ptr {
 
 public:
   // exception_ptr is basically a COW string so it is trivially relocatable.
-  // However, it's not replaceable because destroying and move-constructing could cause
-  // the underlying refcount to hit 0 if we're self-assigning.
+  // It is also replaceable because assignment has normal value semantics.
   using __trivially_relocatable _LIBCPP_NODEBUG = exception_ptr;
-  using __replaceable _LIBCPP_NODEBUG           = void;
+  using __replaceable _LIBCPP_NODEBUG           = exception_ptr;
 
   _LIBCPP_HIDE_FROM_ABI exception_ptr() _NOEXCEPT : __ptr_() {}
   _LIBCPP_HIDE_FROM_ABI exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}

libcxx/include/__locale

@@ -51,10 +51,9 @@ _LIBCPP_HIDE_FROM_ABI const _Facet& use_facet(const locale&);
 class _LIBCPP_EXPORTED_FROM_ABI locale {
 public:
   // locale is essentially a shared_ptr that doesn't support weak_ptrs and never got a move constructor,
-  // so it is trivially relocatable. However, it is not replaceable because self-assignment must prevent
-  // the refcount from hitting 0.
+  // so it is trivially relocatable. Like shared_ptr, it is also replaceable.
   using __trivially_relocatable _LIBCPP_NODEBUG = locale;
-  using __replaceable _LIBCPP_NODEBUG           = void;
+  using __replaceable _LIBCPP_NODEBUG           = locale;
 
   // types:
   class _LIBCPP_EXPORTED_FROM_ABI facet;

libcxx/include/__memory/shared_ptr.h

@@ -316,12 +316,10 @@ class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr {
 #endif
 
   // A shared_ptr contains only two raw pointers which point to the heap and move constructing already doesn't require
-  // any bookkeeping, so it's always trivially relocatable.
-  //
-  // However, it's not replaceable because of self-assignment, which must prevent the refcount from
-  // hitting 0.
+  // any bookkeeping, so it's always trivially relocatable. It is also replaceable because assignment just rebinds the
+  // shared_ptr to manage a different object.
   using __trivially_relocatable _LIBCPP_NODEBUG = shared_ptr;
-  using __replaceable _LIBCPP_NODEBUG           = void;
+  using __replaceable _LIBCPP_NODEBUG           = shared_ptr;
 
 private:
   element_type* __ptr_;
@@ -1215,11 +1213,9 @@ class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr {
 #endif
 
   // A weak_ptr contains only two raw pointers which point to the heap and move constructing already doesn't require
-  // any bookkeeping, so it's always trivially relocatable.
-  //
-  // However, it's not replaceable because we must preserve a non-zero refcount through self-assignment.
+  // any bookkeeping, so it's always trivially relocatable. It's also replaceable for the same reason.
   using __trivially_relocatable _LIBCPP_NODEBUG = weak_ptr;
-  using __replaceable _LIBCPP_NODEBUG           = void;
+  using __replaceable _LIBCPP_NODEBUG           = weak_ptr;
 
 private:
   element_type* __ptr_;

libcxx/include/__type_traits/is_replaceable.h

@@ -21,7 +21,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-// A type is replaceable if `x = std::move(y)` is equivalent to:
+// A type is replaceable if, with `x` and `y` being different objects, `x = std::move(y)` is equivalent to:
 //
 //  std::destroy_at(&x)
 //  std::construct_at(&x, std::move(y))

libcxx/test/libcxx/type_traits/is_replaceable.compile.pass.cpp

@@ -191,7 +191,7 @@ static_assert(std::__is_replaceable<std::deque<int, NonPropagatingStatelessCopyA
 static_assert(std::__is_replaceable<std::deque<int, NonPropagatingStatelessMoveAssignAlloc<int> > >::value, "");
 
 // exception_ptr
-static_assert(!std::__is_replaceable<std::exception_ptr>::value, "");
+static_assert(std::__is_replaceable<std::exception_ptr>::value, "");
 
 // expected
 #if TEST_STD_VER >= 23
@@ -203,7 +203,7 @@ static_assert(!std::__is_replaceable<std::expected<CustomCopyAssignment, CustomC
 
 // locale
 #ifndef TEST_HAS_NO_LOCALIZATION
-static_assert(!std::__is_replaceable<std::locale>::value, "");
+static_assert(std::__is_replaceable<std::locale>::value, "");
 #endif
 
 // optional
@@ -219,7 +219,7 @@ static_assert(!std::__is_replaceable<std::pair<int, CustomCopyAssignment> >::val
 static_assert(!std::__is_replaceable<std::pair<CustomCopyAssignment, CustomCopyAssignment> >::value, "");
 
 // shared_ptr
-static_assert(!std::__is_replaceable<std::shared_ptr<int> >::value, "");
+static_assert(std::__is_replaceable<std::shared_ptr<int> >::value, "");
 
 // tuple
 #if TEST_STD_VER >= 11
@@ -284,6 +284,6 @@ static_assert(std::__is_replaceable<std::vector<int, NonPropagatingStatelessCopy
 static_assert(std::__is_replaceable<std::vector<int, NonPropagatingStatelessMoveAssignAlloc<int> > >::value, "");
 
 // weak_ptr
-static_assert(!std::__is_replaceable<std::weak_ptr<CustomCopyAssignment> >::value, "");
+static_assert(std::__is_replaceable<std::weak_ptr<CustomCopyAssignment> >::value, "");
 
 // TODO: Mark all the replaceable STL types as such