fix(include_local): remove automatic hpx_main.hpp inclusion from local.hpp

hpx/local.hpp is a convenience umbrella header for the Standard Parallel
Toolkit. It must never include hpx_main.hpp automatically because that
header has observable, TU-wide side effects:

  1. On Linux/macOS with HPX_HAVE_DYNAMIC_HPX_MAIN, wrap_main.hpp emits
     non-weak *strong* definitions of hpx_start::include_libhpx_wrap and
     hpx_start::app_name_libhpx_wrap into every TU that includes it.
     These conflict with the definitions in libhpx_wrap.so and cause
     'multiple definition' linker errors in distributed-runtime builds
     (e.g. the 18-contracts-lcos_local CI job).

  2. Without HPX_HAVE_DYNAMIC_HPX_MAIN (static linking, Windows), it
     executes '#define main hpx_startup::user_main', which silently
     renames the program entry point in every TU and breaks test
     executables that define their own main().

Both issues require that hpx_main.hpp remain an *explicit* user opt-in,
included only in the single translation unit that owns the program's
entry point. An umbrella convenience header is the wrong place for it.

Also remove the now-redundant #define HPX_NO_MAIN guard from the
local_header unit test since local.hpp no longer includes hpx_main.hpp.

Refs: #7070
Signed-off-by: shivansh023023 <singhshivansh023@gmail.com>

Author: Hackathon User

libs/core/include_local/include/hpx/local.hpp

@@ -10,25 +10,27 @@
 /// This header bundles the **Standard Parallel Toolkit** -- the most commonly
 /// used HPX facilities for local (single-node) execution:
 ///
-///   - \c hpx/algorithm.hpp  -- Parallel algorithms (for_each, sort, ...)
-///   - \c hpx/execution.hpp  -- Execution policies (par, par_unseq, seq)
-///   - \c hpx/future.hpp     -- Futures and dataflow
-///   - \c hpx/numeric.hpp    -- Parallel numeric (reduce, transform_reduce, ...)
+///   - \c hpx/modules/algorithms.hpp -- Parallel algorithms (for_each, sort, ...)
+///   - \c hpx/modules/execution.hpp  -- Execution policies (par, par_unseq, seq)
+///   - \c hpx/modules/futures.hpp    -- Futures and dataflow
+///   - \c hpx/numeric.hpp            -- Parallel numeric (reduce, transform_reduce, ...)
 ///
 /// **Selection criteria**: each header is part of the HPX core module,
 /// provides ISO C++ Standard Library parallel equivalents, and has no
 /// dependency on the distributed runtime or networking layer.
+///
+/// \note  This header intentionally does NOT include hpx/hpx_main.hpp.
+///        Including hpx_main.hpp has observable side effects: it emits
+///        non-weak symbol definitions (hpx_start::include_libhpx_wrap,
+///        hpx_start::app_name_libhpx_wrap) into every translation unit
+///        that includes it, and redefines 'main' via a preprocessor macro.
+///        Users who need the zero-boilerplate HPX runtime entry-point should
+///        include hpx/hpx_main.hpp explicitly in their *single* main TU.
 
 #pragma once
 
 #include <hpx/config.hpp>
 
-#if !defined(HPX_HAVE_DISTRIBUTED_RUNTIME) && !defined(HPX_NO_MAIN)
-#if __has_include(<hpx/hpx_main.hpp>)
-#include <hpx/hpx_main.hpp>    // hpxinspect:noinclude:hpx/hpx_main.hpp
-#endif
-#endif
-
 // --- Standard Parallel Toolkit (core, no networking dependency) ---
 #include <hpx/modules/algorithms.hpp>
 #include <hpx/modules/execution.hpp>

libs/core/include_local/tests/unit/local_header.cpp

@@ -7,14 +7,10 @@
 // Verify that hpx/local.hpp provides access to the Standard Parallel Toolkit:
 // parallel algorithms, numeric algorithms, and execution policies.
 //
-// We use hpx::local::init to avoid any dependency on the full wrap module.
+// We use hpx::local::init to drive the HPX runtime without requiring any
+// dependency on the wrap module (hpx_main.hpp / HPX::wrap_main).
 
 #include <hpx/config.hpp>
-
-// Define HPX_NO_MAIN to ensure the test itself does not trigger inclusion
-// of hpx_main.hpp from local.hpp, thus bypassing any circular dependency
-// during the core module test build.
-#define HPX_NO_MAIN
 #include <hpx/init.hpp>
 #include <hpx/local.hpp>