Merge pull request #7298 from Priyanshi507/reflect-action-auto-register

actions_base: add auto-registration to reflect_action

Author: hkaiser

libs/full/actions_base/include/hpx/actions_base/reflect_action.hpp

@@ -14,6 +14,7 @@
 #if defined(HPX_HAVE_CXX26_REFLECTION)
 
 #include <hpx/actions_base/basic_action.hpp>
+#include <hpx/actions_base/detail/invocation_count_registry.hpp>
 #include <hpx/actions_base/plain_action.hpp>
 #include <hpx/modules/serialization.hpp>
 
@@ -46,13 +47,16 @@ namespace hpx::actions {
     /// reflect_action<F> integrates with HPX's action system by inheriting
     /// from basic_action<detail::plain_function, R(Ps...), reflect_action<F>>.
     /// All properties are derived automatically from the reflected function F.
+    /// Invocation count registration is automatic via a static member --
+    /// no HPX_REGISTER_ACTION call is needed for reflection-based actions.
     ///
     /// \tparam F  A std::meta::info reflection of a free function.
-    template <std::meta::info F>
+    /// \tparam Derived  Derived type for CRTP extensibility (default: void).
+    template <std::meta::info F, typename Derived = void>
     struct reflect_action
       : basic_action<hpx::actions::detail::plain_function,
             typename detail::reflect_action_base<F>::func_type,
-            reflect_action<F>>
+            detail::action_type_t<reflect_action<F, Derived>, Derived>>
     {
         /// The function type (e.g. int(double, double))
         using func_type = [:std::meta::type_of(F):];
@@ -81,12 +85,23 @@ namespace hpx::actions {
             naming::address::component_type /*comptype*/, Ts&&... vs)
         {
             using base_t = basic_action<hpx::actions::detail::plain_function,
-                func_type, reflect_action<F>>;
+                func_type, detail::action_type_t<reflect_action, Derived>>;
             base_t::increment_invocation_count();
             return func_ptr(HPX_FORWARD(Ts, vs)...);
         }
+
+        /// Automatic invocation count registration -- eliminates the need
+        /// for HPX_REGISTER_ACTION for reflection-based plain actions.
+        static detail::register_action_invocation_count<reflect_action>
+            invocation_count_registrar_;
     };
 
+    /// \cond NOINTERNAL
+    template <std::meta::info F, typename Derived>
+    detail::register_action_invocation_count<reflect_action<F, Derived>>
+        reflect_action<F, Derived>::invocation_count_registrar_;
+    /// \endcond
+
 }    // namespace hpx::actions
 
 #endif    // HPX_HAVE_CXX26_REFLECTION

libs/full/actions_base/tests/unit/reflect_action_test.cpp

@@ -13,6 +13,7 @@
 
 #include <cstddef>
 #include <string>
+#include <type_traits>
 
 namespace app {
 
@@ -89,5 +90,15 @@ int main()
         HPX_TEST_EQ(compute_action::func_ptr(3.0, 4.0), 7);
     }
 
+    // Test: auto-registration static member exists (compile-time check)
+    // This verifies that reflect_action has the invocation_count_registrar_
+    // static member which enables automatic registration without HPX_REGISTER_ACTION
+    {
+        HPX_ACTION(app::compute, compute_action);
+        using registrar_type =
+            decltype(compute_action::invocation_count_registrar_);
+        static_assert(!std::is_void_v<registrar_type>,
+            "invocation_count_registrar_ must exist");
+    }
     return hpx::util::report_errors();
 }