Review comments

ldionne · ldionne · commit be5f6203ee64 · 2025-03-24T15:02:47.000-04:00
diff --git a/libcxx/include/__expected/expected.h b/libcxx/include/__expected/expected.h
@@ -472,7 +472,7 @@ class expected : private __expected_base<_Tp, _Err> {
                       expected,
                       void>;
   using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable<_Tp>::value && __is_replaceable<_Err>::value, expected, void>;
+      __conditional_t<__is_replaceable_v<_Tp> && __is_replaceable_v<_Err>, expected, void>;
 
   template <class _Up>
   using rebind = expected<_Up, error_type>;
diff --git a/libcxx/include/__memory/unique_ptr.h b/libcxx/include/__memory/unique_ptr.h
@@ -146,7 +146,7 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr {
       unique_ptr,
       void>;
   using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable<pointer>::value && __is_replaceable<deleter_type>::value, unique_ptr, void>;
+      __conditional_t<__is_replaceable_v<pointer> && __is_replaceable_v<deleter_type>, unique_ptr, void>;
 
 private:
   _LIBCPP_COMPRESSED_PAIR(pointer, __ptr_, deleter_type, __deleter_);
@@ -414,7 +414,7 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
       unique_ptr,
       void>;
   using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable<pointer>::value && __is_replaceable<deleter_type>::value, unique_ptr, void>;
+      __conditional_t<__is_replaceable_v<pointer> && __is_replaceable_v<deleter_type>, unique_ptr, void>;
 
 private:
   template <class _Up, class _OtherDeleter>
diff --git a/libcxx/include/__split_buffer b/libcxx/include/__split_buffer
@@ -74,7 +74,7 @@ public:
       __split_buffer,
       void>;
   using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable<pointer>::value && __container_allocator_is_replaceable<__alloc_traits>::value,
+      __conditional_t<__is_replaceable_v<pointer> && __container_allocator_is_replaceable<__alloc_traits>::value,
                       __split_buffer,
                       void>;
 
diff --git a/libcxx/include/__type_traits/is_replaceable.h b/libcxx/include/__type_traits/is_replaceable.h
@@ -38,6 +38,9 @@ struct __is_replaceable : is_trivially_copyable<_Tp> {};
 template <class _Tp>
 struct __is_replaceable<_Tp, __enable_if_t<is_same<_Tp, typename _Tp::__replaceable>::value> > : true_type {};
 
+template <class _Tp>
+inline const bool __is_replaceable_v = __is_replaceable<_Tp>::value;
+
 // Determines whether an allocator member of a container is replaceable.
 //
 // We take into account whether the allocator is propagated on assignments. If the allocator
@@ -52,7 +55,7 @@ struct __container_allocator_is_replaceable
                         _AllocatorTraits::is_always_equal::value ||
                             (_AllocatorTraits::propagate_on_container_move_assignment::value &&
                              _AllocatorTraits::propagate_on_container_copy_assignment::value &&
-                             __is_replaceable<typename _AllocatorTraits::allocator_type>::value)> {};
+                             __is_replaceable_v<typename _AllocatorTraits::allocator_type>)> {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/libcxx/include/__utility/pair.h b/libcxx/include/__utility/pair.h
@@ -74,8 +74,7 @@ struct _LIBCPP_TEMPLATE_VIS pair
       __conditional_t<__libcpp_is_trivially_relocatable<_T1>::value && __libcpp_is_trivially_relocatable<_T2>::value,
                       pair,
                       void>;
-  using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable<_T1>::value && __is_replaceable<_T2>::value, pair, void>;
+  using __replaceable _LIBCPP_NODEBUG = __conditional_t<__is_replaceable_v<_T1> && __is_replaceable_v<_T2>, pair, void>;
 
   _LIBCPP_HIDE_FROM_ABI pair(pair const&) = default;
   _LIBCPP_HIDE_FROM_ABI pair(pair&&)      = default;
diff --git a/libcxx/include/__vector/vector.h b/libcxx/include/__vector/vector.h
@@ -122,7 +122,7 @@ class _LIBCPP_TEMPLATE_VIS vector {
       vector,
       void>;
   using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable<pointer>::value && __container_allocator_is_replaceable<__alloc_traits>::value,
+      __conditional_t<__is_replaceable_v<pointer> && __container_allocator_is_replaceable<__alloc_traits>::value,
                       vector,
                       void>;
 
diff --git a/libcxx/include/array b/libcxx/include/array
@@ -176,7 +176,7 @@ template <class _Tp, size_t _Size>
 struct _LIBCPP_TEMPLATE_VIS array {
   using __trivially_relocatable _LIBCPP_NODEBUG =
       __conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, array, void>;
-  using __replaceable _LIBCPP_NODEBUG = __conditional_t<__is_replaceable<_Tp>::value, array, void>;
+  using __replaceable _LIBCPP_NODEBUG = __conditional_t<__is_replaceable_v<_Tp>, array, void>;
 
   // types:
   using __self _LIBCPP_NODEBUG = array;
diff --git a/libcxx/include/deque b/libcxx/include/deque
@@ -532,7 +532,7 @@ public:
       deque,
       void>;
   using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable<__map>::value && __container_allocator_is_replaceable<__alloc_traits>::value,
+      __conditional_t<__is_replaceable_v<__map> && __container_allocator_is_replaceable<__alloc_traits>::value,
                       deque,
                       void>;
 
diff --git a/libcxx/include/optional b/libcxx/include/optional
@@ -591,7 +591,7 @@ public:
 
   using __trivially_relocatable _LIBCPP_NODEBUG =
       conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, optional, void>;
-  using __replaceable _LIBCPP_NODEBUG = conditional_t<__is_replaceable<_Tp>::value, optional, void>;
+  using __replaceable _LIBCPP_NODEBUG = conditional_t<__is_replaceable_v<_Tp>, optional, void>;
 
 private:
   // Disable the reference extension using this static assert.
diff --git a/libcxx/include/string b/libcxx/include/string
@@ -766,7 +766,7 @@ public:
       void>;
 #  endif
   using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable<pointer>::value && __container_allocator_is_replaceable<__alloc_traits>::value,
+      __conditional_t<__is_replaceable_v<pointer> && __container_allocator_is_replaceable<__alloc_traits>::value,
                       basic_string,
                       void>;
 
diff --git a/libcxx/include/variant b/libcxx/include/variant
@@ -1177,7 +1177,7 @@ class _LIBCPP_TEMPLATE_VIS _LIBCPP_DECLSPEC_EMPTY_BASES _LIBCPP_NO_SPECIALIZATIO
 public:
   using __trivially_relocatable _LIBCPP_NODEBUG =
       conditional_t<_And<__libcpp_is_trivially_relocatable<_Types>...>::value, variant, void>;
-  using __replaceable = conditional_t<_And<__is_replaceable<_Types>...>::value, variant, void>;
+  using __replaceable _LIBCPP_NODEBUG = conditional_t<_And<__is_replaceable<_Types>...>::value, variant, void>;
 
   template <bool _Dummy                                                                               = true,
             enable_if_t<__dependent_type<is_default_constructible<__first_type>, _Dummy>::value, int> = 0>
diff --git a/libcxx/test/libcxx/type_traits/is_replaceable.compile.pass.cpp b/libcxx/test/libcxx/type_traits/is_replaceable.compile.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: FROZEN-CXX03-HEADERS-FIXME
+
 #include <__type_traits/is_replaceable.h>
 #include <array>
 #include <deque>
@@ -31,26 +33,44 @@ template <class T>
 struct NonPropagatingStatefulMoveAssignAlloc : std::allocator<T> {
   using propagate_on_container_move_assignment = std::false_type;
   using is_always_equal                        = std::false_type;
+  template <class U>
+  struct rebind {
+    using other = NonPropagatingStatefulMoveAssignAlloc<U>;
+  };
 };
 
 template <class T>
 struct NonPropagatingStatefulCopyAssignAlloc : std::allocator<T> {
   using propagate_on_container_copy_assignment = std::false_type;
   using is_always_equal                        = std::false_type;
+  template <class U>
+  struct rebind {
+    using other = NonPropagatingStatefulCopyAssignAlloc<U>;
+  };
 };
 
 template <class T>
 struct NonPropagatingStatelessMoveAssignAlloc : std::allocator<T> {
   using propagate_on_container_move_assignment = std::false_type;
   using is_always_equal                        = std::true_type;
+  template <class U>
+  struct rebind {
+    using other = NonPropagatingStatelessMoveAssignAlloc<U>;
+  };
 };
 
 template <class T>
 struct NonPropagatingStatelessCopyAssignAlloc : std::allocator<T> {
   using propagate_on_container_copy_assignment = std::false_type;
   using is_always_equal                        = std::true_type;
+  template <class U>
+  struct rebind {
+    using other = NonPropagatingStatelessCopyAssignAlloc<U>;
+  };
 };
 
+static_assert(!std::__is_replaceable<test_allocator<char> >::value, ""); // we use that property below
+
 struct Empty {};
 static_assert(std::__is_replaceable<char>::value, "");
 static_assert(std::__is_replaceable<int>::value, "");
