update relocation semantics to match p2786r13

Signed-off-by: guptapratykshh <pratykshgupta9999@gmail.com>

Author: guptapratykshh

libs/core/type_support/CMakeLists.txt

@@ -20,6 +20,7 @@ set(type_support_headers
     hpx/type_support/extra_data.hpp
     hpx/type_support/identity.hpp
     hpx/type_support/is_relocatable.hpp
+    hpx/type_support/is_replaceable.hpp
     hpx/type_support/is_trivially_relocatable.hpp
     hpx/type_support/is_contiguous_iterator.hpp
     hpx/type_support/lazy_conditional.hpp

libs/core/type_support/include/hpx/type_support/is_replaceable.hpp

@@ -0,0 +1,26 @@
+//  Copyright (c) 2025 Isidoros Tsaousis-Seiras
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <hpx/config.hpp>
+
+#include <type_traits>
+
+namespace hpx::experimental {
+
+    HPX_CXX_EXPORT template <typename T>
+    struct is_replaceable
+      : std::bool_constant<std::is_object_v<T> &&
+            std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
+            std::is_destructible_v<T> && !std::is_volatile_v<T>>
+    {
+    };
+
+    HPX_CXX_EXPORT template <typename T>
+    inline constexpr bool is_replaceable_v = is_replaceable<T>::value;
+
+}    // namespace hpx::experimental

libs/core/type_support/include/hpx/type_support/is_trivially_relocatable.hpp

@@ -12,6 +12,13 @@
 
 namespace hpx::experimental {
 
+#if defined(__cpp_lib_trivially_relocatable)
+    template <typename T>
+    struct is_trivially_relocatable : std::is_trivially_relocatable<T>
+    {
+    };
+#else
+
     // All trivially copyable types are trivially relocatable
     // Other types should default to false.
     HPX_CXX_CORE_EXPORT template <typename T>
@@ -74,6 +81,8 @@ namespace hpx::experimental {
     {
     };
 
+#endif
+
     HPX_CXX_CORE_EXPORT template <typename T>
     inline constexpr bool is_trivially_relocatable_v =
         is_trivially_relocatable<T>::value;

libs/core/type_support/include/hpx/type_support/relocate_at.hpp

@@ -15,7 +15,8 @@
 #include <cstring>
 #include <type_traits>
 
-#if defined(HPX_HAVE_P1144_STD_RELOCATE_AT)
+#if defined(HPX_HAVE_P1144_STD_RELOCATE_AT) ||                                 \
+    defined(__cpp_lib_trivially_relocatable)
 #include <memory>
 #endif
 
@@ -118,10 +119,14 @@ namespace hpx::experimental {
         // noexcept if the memmove path is taken or if the move path is noexcept
         noexcept(detail::relocate_at_helper(src, dst)))
     {
+#if defined(__cpp_lib_trivially_relocatable)
+        return std::relocate_at(src, dst);
+#else
         static_assert(is_relocatable_v<T>,
             "new (dst) T(std::move(*src)) must be well-formed");
 
         return detail::relocate_at_helper(src, dst);
+#endif
     }
 
     HPX_CXX_CORE_EXPORT template <typename T>

libs/core/type_support/tests/unit/CMakeLists.txt

@@ -32,7 +32,7 @@ endforeach()
 
 if(HPX_WITH_COMPILE_ONLY_TESTS)
   # add compile time tests
-  set(compile_tests is_contiguous_iterator is_relocatable
+  set(compile_tests is_contiguous_iterator is_relocatable is_replaceable
                     is_trivially_relocatable
   )
 

libs/core/type_support/tests/unit/is_replaceable.cpp

@@ -0,0 +1,71 @@
+//  Copyright (c) 2025 Isidoros Tsaousis-Seiras
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <hpx/type_support/is_replaceable.hpp>
+
+#include <cassert>
+#include <memory>
+#include <mutex>
+#include <type_traits>
+
+using hpx::experimental::is_replaceable_v;
+
+// Integral types are replaceable
+static_assert(is_replaceable_v<int>);
+// Const types are not assignable
+static_assert(!is_replaceable_v<int const>);
+
+// Pointer types are replaceable
+static_assert(is_replaceable_v<int*>);
+static_assert(is_replaceable_v<int const*>);
+
+// Function pointers are replaceable
+static_assert(is_replaceable_v<int (*)()>);
+
+// Arrays are not assignable
+static_assert(!is_replaceable_v<int[]>);
+static_assert(!is_replaceable_v<int[4]>);
+
+// References are not objects
+static_assert(!is_replaceable_v<int&>);
+static_assert(!is_replaceable_v<int&&>);
+
+// Void types
+static_assert(!is_replaceable_v<void>);
+
+// std::mutex is not move assignable
+static_assert(!is_replaceable_v<std::mutex>);
+
+struct not_destructible
+{
+    not_destructible(not_destructible const&);
+    not_destructible(not_destructible&&);
+    ~not_destructible() = delete;
+};
+static_assert(!is_replaceable_v<not_destructible>);
+
+struct not_move_assignable
+{
+    not_move_assignable& operator=(not_move_assignable&&) = delete;
+};
+static_assert(!is_replaceable_v<not_move_assignable>);
+
+struct not_move_constructible
+{
+    not_move_constructible(not_move_constructible&&) = delete;
+    not_move_constructible& operator=(not_move_constructible&&);
+};
+static_assert(!is_replaceable_v<not_move_constructible>);
+
+struct move_assignable
+{
+    move_assignable(move_assignable&&);
+    move_assignable& operator=(move_assignable&&);
+    ~move_assignable();
+};
+static_assert(is_replaceable_v<move_assignable>);
+
+int main() {}