async: add hpx::async<^^func>(target, ...) reflection overload

Adds a new hpx::async overload that accepts a std::meta::info
reflection of a free function as a non-type template parameter,
eliminating the need to define an explicit action type:

    // Before: explicit action type required
    using my_action = hpx::actions::reflect_action<^^app::compute>;
    hpx::async<my_action>(target, args...);

    // After: direct reflection syntax
    hpx::async<^^app::compute>(target, args...);

The overload is constrained to accept only viable distributed
targets (hpx::id_type, client types, distribution policies),
matching the existing async_action_dispatch specializations.
Internally it constructs reflect_action<F>{} and delegates to
the existing hpx::async(action, target, ...) machinery — no
changes to dispatch internals required.

Guarded by HPX_HAVE_CXX26_REFLECTION.

Suggested by hkaiser as a natural extension of the reflection-based
action work from PRs TheHPXProject#7298, TheHPXProject#7311, TheHPXProject#7342, TheHPXProject#7349.

Signed-off-by: Priyanshi507 <hiiuiuiabi@gmail.com>

Author: Priyanshi507

cmake/HPX_CollectStdHeaders.cmake

@@ -105,6 +105,10 @@ set(STANDARD_LIBRARY_HEADERS
     "<cwctype>"
 )
 
+if(HPX_WITH_CXX26_REFLECTION)
+  list(APPEND STANDARD_LIBRARY_HEADERS "<meta>")
+endif()
+
 # Function to extract #includes from a file recursively
 function(hpx_extract_includes_from_file module)
 

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

@@ -129,6 +129,7 @@ namespace hpx::actions {
         typename Component =
             typename detail::reflect_component_action_base<F>::component_type,
         typename Derived = void>
+        requires(!std::meta::is_function(F))
     struct reflect_component_action
       : basic_action<Component,
             typename detail::reflect_component_action_base<F>::func_type,
@@ -180,6 +181,7 @@ namespace hpx::actions {
         typename Component =
             typename detail::reflect_component_action_base<F>::component_type,
         typename Derived = void>
+        requires(!std::meta::is_function(F))
     struct reflect_component_direct_action
       : reflect_component_action<F, Component,
             detail::action_type_t<
@@ -232,6 +234,7 @@ namespace hpx::actions {
     /// \tparam F  A std::meta::info reflection of a free function.
     /// \tparam Derived  Derived type for CRTP extensibility (default: void).
     template <std::meta::info F, typename Derived = void>
+        requires(std::meta::is_function(F))
     struct reflect_action
       : basic_action<hpx::actions::detail::plain_function,
             typename detail::reflect_action_base<F>::func_type,
@@ -292,6 +295,7 @@ namespace hpx::actions {
     /// \tparam F       A std::meta::info reflection of a free function.
     /// \tparam Derived CRTP derived type (defaults to void).
     template <std::meta::info F, typename Derived = void>
+        requires(std::meta::is_function(F))
     struct reflect_direct_action
       : reflect_action<F,
             detail::action_type_t<reflect_direct_action<F, Derived>, Derived>>

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

@@ -141,6 +141,19 @@ int main()
         hpx::naming::component_type comptype{};
         direct_broadcast::invoke(lva, comptype, 42);
     }
+    // Test: hpx::async<^^func>(target, ...) overload is directly callable
+    // (compile-time check -- full runtime dispatch requires a live HPX locality)
+    {
+        // Verify the overload is well-formed for id_type targets
+        static_assert(
+            requires(hpx::id_type id) {
+                hpx::async<^^app::compute>(id, 3.0, 4.0);
+            }, "hpx::async<^^func>(id_type, ...) must be well-formed");
+        // Verify non-function reflections are rejected by the constraint
+        static_assert(
+            !requires(hpx::id_type id) { hpx::async<^^int>(id, 3.0, 4.0); },
+            "hpx::async<^^non-function> must be ill-formed");
+    }
     return hpx::util::report_errors();
 }
 

libs/full/async_distributed/include/hpx/async_distributed/async.hpp

@@ -218,6 +218,28 @@ namespace hpx {
         return detail::async_action_dispatch<Action, std::decay_t<F>>::call(
             HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...);
     }
+
+#if defined(HPX_HAVE_CXX26_REFLECTION)
+    /// \brief Reflection-based async overload.
+    ///
+    /// Allows calling hpx::async<^^func>(target, ...) directly without
+    /// defining an explicit action type. Internally constructs
+    /// reflect_action<F> and delegates to the existing async machinery.
+    ///
+    /// \tparam F      A std::meta::info reflection of a free function.
+    /// \tparam Target id_type, client, or distribution policy.
+    /// \tparam Ts     Additional arguments to pass to the function.
+    template <std::meta::info F, typename Target, typename... Ts>
+        requires(std::meta::is_function(F) &&
+            (std::is_same_v<std::decay_t<Target>, hpx::id_type> ||
+                hpx::traits::is_client_v<std::decay_t<Target>> ||
+                hpx::traits::is_distribution_policy_v<std::decay_t<Target>>) )
+    HPX_CXX_EXPORT HPX_FORCEINLINE auto async(Target&& target, Ts&&... ts)
+    {
+        return hpx::async(hpx::actions::reflect_action<F>{},
+            HPX_FORWARD(Target, target), HPX_FORWARD(Ts, ts)...);
+    }
+#endif    // HPX_HAVE_CXX26_REFLECTION
 }    // namespace hpx
 
 ///////////////////////////////////////////////////////////////////////////////

libs/full/async_distributed/tests/unit/CMakeLists.txt

@@ -34,6 +34,11 @@ set(tests
 set(async_continue_PARAMETERS LOCALITIES 2)
 set(async_continue_cb_PARAMETERS LOCALITIES 2)
 set(async_remote_PARAMETERS LOCALITIES 2)
+
+if(HPX_WITH_CXX26_REFLECTION)
+  set(tests ${tests} async_remote_reflect)
+  set(async_remote_reflect_PARAMETERS LOCALITIES 2)
+endif()
 set(async_remote_client_PARAMETERS LOCALITIES 2)
 set(async_cb_remote_PARAMETERS LOCALITIES 2)
 set(async_cb_remote_client_PARAMETERS LOCALITIES 2)

libs/full/async_distributed/tests/unit/async_remote_reflect.cpp

@@ -0,0 +1,62 @@
+//  Copyright (c) 2026 Priyanshi Sharma
+//
+//  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/config.hpp>
+#if !defined(HPX_COMPUTE_DEVICE_CODE)
+#if defined(HPX_HAVE_CXX26_REFLECTION)
+
+#include <hpx/hpx_init.hpp>
+#include <hpx/include/actions.hpp>
+#include <hpx/include/async.hpp>
+#include <hpx/include/runtime.hpp>
+#include <hpx/modules/testing.hpp>
+
+#include <cstdint>
+#include <vector>
+
+///////////////////////////////////////////////////////////////////////////////
+std::int32_t reflect_increment(std::int32_t i)
+{
+    return i + 1;
+}
+HPX_PLAIN_ACTION(reflect_increment)
+
+///////////////////////////////////////////////////////////////////////////////
+void test_async_reflect(hpx::id_type const& target)
+{
+    // Test: hpx::async<^^func>(target, ...) -- reflection-based syntax
+    // No explicit action type needed
+    {
+        hpx::future<std::int32_t> f1 =
+            hpx::async<^^reflect_increment>(target, 42);
+        HPX_TEST_EQ(f1.get(), 43);
+    }
+    {
+        hpx::future<std::int32_t> f1 =
+            hpx::async<^^reflect_increment>(hpx::launch::async, target, 42);
+        HPX_TEST_EQ(f1.get(), 43);
+    }
+}
+
+int hpx_main()
+{
+    std::vector<hpx::id_type> localities = hpx::find_all_localities();
+    for (hpx::id_type const& id : localities)
+    {
+        test_async_reflect(id);
+    }
+    return hpx::finalize();
+}
+
+int main(int argc, char* argv[])
+{
+    HPX_TEST_EQ_MSG(
+        hpx::init(argc, argv), 0, "HPX main exited with non-zero status");
+    return hpx::util::report_errors();
+}
+
+#endif    // HPX_HAVE_CXX26_REFLECTION
+#endif    // HPX_COMPUTE_DEVICE_CODE