Fix unused variable warnings

.gitignore

@@ -12,7 +12,7 @@
 /Dockerfile
 /.dockerignore
 .ycm_extra_conf.py
-apex
+/apex
 packages
 .vscode
 .ccls-cache

CMakeLists.txt

@@ -2006,10 +2006,6 @@ if(HPX_WITH_COMPILER_WARNINGS)
     # we ignore this warning
     hpx_add_compile_flag_if_available(-Wno-noexcept-type)
 
-    # These are usually benign and can't be suppressed because of interface
-    # requirements
-    hpx_add_compile_flag_if_available(-Wno-unused-parameter)
-
     # Be extra strict about format checks Boost.Logging is built on fprintf,
     # sadly
     hpx_add_compile_flag_if_available(-Wformat=2)

cmake/HPX_AddCompileTest.cmake

@@ -116,7 +116,7 @@ function(add_hpx_header_tests category)
       # generate the test
       file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${full_test_file}
            "#include <${relpath}>\n" "#ifndef HPX_MAIN_DEFINED\n"
-           "int main(int argc, char** argv) { return 0; }\n" "#endif\n"
+           "int main() { return 0; }\n" "#endif\n"
       )
 
       set(exclude_all_pos -1)
@@ -133,7 +133,8 @@ function(add_hpx_header_tests category)
         SOURCE_ROOT "${CMAKE_CURRENT_BINARY_DIR}/${header_dir}"
         FOLDER "Tests/Headers/${header_dir}"
         COMPONENT_DEPENDENCIES ${${category}_COMPONENT_DEPENDENCIES}
-        DEPENDENCIES ${${category}_DEPENDENCIES} ${_additional_flags}
+        DEPENDENCIES ${${category}_DEPENDENCIES} hpx_private_flags
+                     hpx_public_flags ${_additional_flags}
       )
 
     endif()
@@ -142,8 +143,8 @@ function(add_hpx_header_tests category)
   set(test_name "all_headers")
   set(all_headers_test_file "${CMAKE_CURRENT_BINARY_DIR}/${test_name}.cpp")
   file(WRITE ${all_headers_test_file}
-       ${all_headers} "#ifndef HPX_MAIN_DEFINED\n"
-       "int main(int argc, char** argv) { return 0; }\n" "#endif\n"
+       ${all_headers} "#ifndef HPX_MAIN_DEFINED\n" "int main() { return 0; }\n"
+       "#endif\n"
   )
 
   add_hpx_headers_compile_test(

components/component_storage/include/hpx/components/component_storage/server/migrate_to_storage.hpp

@@ -61,9 +61,8 @@ namespace hpx { namespace components { namespace server
         // clean up (source) memory of migrated object
         template <typename Component>
         naming::id_type migrate_to_storage_here_cleanup(
-            future<naming::id_type> f,
-            std::shared_ptr<Component> ptr,
-            naming::id_type const& to_migrate)
+            future<naming::id_type> f, std::shared_ptr<Component> ptr,
+            naming::id_type const& /* to_migrate */)
         {
             ptr->mark_as_migrated();
             return f.get();

components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_decl.hpp

@@ -927,7 +927,7 @@ namespace hpx
         /// \param pos   Position of the element in the vector
         /// \param val   The value to be copied
         ///
-        void set_values(launch::sync_policy, size_type part,
+        void set_values(launch::sync_policy, size_type /* part */,
             std::vector<size_type> const& pos, std::vector<T> const& val)
         {
             set_values(pos, val).get();

components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_segmented_iterator.hpp

@@ -281,12 +281,12 @@ namespace hpx
         friend class hpx::serialization::access;
 
         template <typename Archive>
-        void load(Archive& ar, unsigned version)
+        void load(Archive& ar, unsigned /* version */)
         {
             ar & partition_ & local_index_;
         }
         template <typename Archive>
-        void save(Archive& ar, unsigned version) const
+        void save(Archive& ar, unsigned /* version */) const
         {
             ar & partition_ & local_index_;
         }
@@ -435,12 +435,12 @@ namespace hpx
         friend class hpx::serialization::access;
 
         template <typename Archive>
-        void load(Archive& ar, unsigned version)
+        void load(Archive& ar, unsigned /* version */)
         {
             ar & partition_ & local_index_;
         }
         template <typename Archive>
-        void save(Archive& ar, unsigned version) const
+        void save(Archive& ar, unsigned /* version */) const
         {
             ar & partition_ & local_index_;
         }

components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_view.hpp

@@ -9,12 +9,13 @@
 #pragma once
 
 #include <hpx/assert.hpp>
+#include <hpx/async_base/launch_policy.hpp>
 #include <hpx/collectives/spmd_block.hpp>
 #include <hpx/components/containers/partitioned_vector/partitioned_vector.hpp>
 #include <hpx/components/containers/partitioned_vector/partitioned_vector_segmented_iterator.hpp>
 #include <hpx/components/containers/partitioned_vector/partitioned_vector_view_iterator.hpp>
-#include <hpx/async_base/launch_policy.hpp>
 #include <hpx/type_support/pack.hpp>
+#include <hpx/type_support/unused.hpp>
 
 #include <array>
 #include <cstddef>
@@ -104,6 +105,7 @@ namespace hpx
             HPX_ASSERT_MSG(limit <= std::distance(begin,last), \
                 "Space dedicated to the described partitioned_vector_view " \
                 "is too small");
+            HPX_UNUSED(last);
 
             // Update end_
             end_  += hw_basis_[N-1] * sw_sizes.begin()[N-1];

components/containers/partitioned_vector/tests/regressions/partitioned_vector_2201.cpp

@@ -37,12 +37,12 @@ struct random_fill
     std::uniform_int_distribution<> dist;
 
     template <typename Archive>
-    void serialize(Archive& ar, unsigned)
+    void serialize(Archive&, unsigned)
     {}
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-int hpx_main(hpx::program_options::variables_map& vm)
+int hpx_main()
 {
     if (hpx::get_locality_id() == 0)
     {

components/iostreams/src/standard_streams.cpp

@@ -63,7 +63,7 @@ namespace hpx { namespace iostreams { namespace detail
     }
 
     ///////////////////////////////////////////////////////////////////////////
-    void release_ostream(char const* name, naming::id_type const& id)
+    void release_ostream(char const* name, naming::id_type const& /* id */)
     {
         LRT_(info) << "detail::release_ostream: destroying '" << name
                    << "' stream object";

components/iostreams/tests/CMakeLists.txt

@@ -34,5 +34,6 @@ if(HPX_WITH_TESTS_HEADERS)
     HEADERS ${iostreams_headers}
     HEADER_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/include"
     COMPONENT_DEPENDENCIES iostreams
+    EXCLUDE hpx/include/iostreams.hpp
   )
 endif()

components/iostreams/tests/regressions/lost_output_2236.cpp

@@ -372,7 +372,7 @@ namespace gc { namespace server {
         HPX_TEST_LT(std::size_t(0), cd->wc);
         check_recover_done();
     }
-    void collectable::done(hpx::id_type child)
+    void collectable::done(hpx::id_type)
     {
         HPX_TEST_LT(std::size_t(0), cd->wc);
         cd->wc--;

components/iostreams/tests/regressions/no_output_1173.cpp

@@ -35,7 +35,7 @@ void on_shutdown(std::string const& expected)
     on_shutdown_executed = true;
 }
 
-int hpx_main(hpx::program_options::variables_map& vm)
+int hpx_main()
 {
     typedef hpx::future<void> wait_for_worker;
     std::vector<wait_for_worker> futures;

components/performance_counters/papi/src/server/papi.cpp

@@ -146,7 +146,7 @@ namespace hpx { namespace performance_counters { namespace papi { namespace serv
         return true;
     }
 
-    bool thread_counters::terminate(std::uint32_t tix)
+    bool thread_counters::terminate(std::uint32_t)
     {
         std::lock_guard<mutex_type> m(mtx_);
         return finalize();

components/performance_counters/papi/tests/regressions/papi_counters_segfault_1890.cpp

@@ -13,7 +13,7 @@
 
 #include <cstdint>
 
-int hpx_main(int argc, char ** argv)
+int hpx_main()
 {
 #if defined(HPX_HAVE_PAPI)
     using hpx::performance_counters::performance_counter;

components/process/include/hpx/components/process/util/posix/initializers/wait_on_latch.hpp

@@ -29,7 +29,7 @@ namespace hpx { namespace components { namespace process { namespace posix
             {}
 
             template <typename PosixExecutor>
-            void on_fork_success(PosixExecutor &e) const
+            void on_fork_success(PosixExecutor&) const
             {
                 // wait for the newly launched HPX locality to connect back here
                 hpx::lcos::latch l(2);

examples/1d_stencil/1d_stencil_4_throttle.cpp

@@ -76,7 +76,7 @@ void setup_counters()
     counters_initialized = true;
 }
 
-bool test_function(apex_context const& context)
+bool test_function(apex_context const&)
 {
     if (!counters_initialized)
         return false;

examples/1d_stencil/1d_stencil_5.cpp

@@ -93,7 +93,9 @@ struct partition_data
     friend class hpx::serialization::access;
 
     template <typename Archive>
-    void serialize(Archive& ar, const unsigned int version) const {}
+    void serialize(Archive&, const unsigned int) const
+    {
+    }
 
 private:
     buffer_type data_;

examples/1d_stencil/1d_stencil_6.cpp

@@ -110,9 +110,11 @@ struct partition_data
     friend class hpx::serialization::access;
 
     template <typename Archive>
-    void serialize(Archive& ar, const unsigned int version)
+    void serialize(Archive& ar, const unsigned int)
     {
+        // clang-format off
         ar & data_ & size_ & min_index_;
+        // clang-format on
     }
 
 private:

examples/1d_stencil/1d_stencil_7.cpp

@@ -110,9 +110,11 @@ struct partition_data
     friend class hpx::serialization::access;
 
     template <typename Archive>
-    void serialize(Archive& ar, const unsigned int version)
+    void serialize(Archive& ar, const unsigned int)
     {
+        // clang-format off
         ar & data_ & size_ & min_index_;
+        // clang-format on
     }
 
 private:

examples/1d_stencil/1d_stencil_8.cpp

@@ -175,9 +175,11 @@ struct partition_data
     friend class hpx::serialization::access;
 
     template <typename Archive>
-    void serialize(Archive& ar, const unsigned int version)
+    void serialize(Archive& ar, const unsigned int)
     {
+        // clang-format off
         ar & data_ & size_ & min_index_;
+        // clang-format on
     }
 
 private:

examples/apex/apex_balance.cpp

@@ -98,10 +98,10 @@ int hpx_main(hpx::program_options::variables_map& vm)
 
 void register_policy(void) {
     periodic_policy_handle =
-    apex::register_periodic_policy(1000000, [](apex_context const& context) {
-        std::cout << "Periodic policy!" << std::endl;
-        return APEX_NOERROR;
-    });
+        apex::register_periodic_policy(1000000, [](apex_context const&) {
+            std::cout << "Periodic policy!" << std::endl;
+            return APEX_NOERROR;
+        });
 }
 
 ///////////////////////////////////////////////////////////////////////////////

examples/apex/apex_policy_engine_active_thread_count.cpp

@@ -109,7 +109,8 @@ int hpx_main(hpx::program_options::variables_map& vm)
     return hpx::finalize(); // Handles HPX shutdown
 }
 
-bool test_function(apex_context const& context) {
+bool test_function(apex_context const&)
+{
     if (!counters_initialized) return false;
     try {
         performance_counter counter(get_counter());

examples/apex/apex_policy_engine_events.cpp

@@ -89,8 +89,7 @@ int main(int argc, char* argv[])
         ;
 
     const apex_event_type when = APEX_START_EVENT;
-    policy_handle = apex::register_policy(when,
-        [](apex_context const& context){
+    policy_handle = apex::register_policy(when, [](apex_context const&) {
         std::cout << "Start event!" << std::endl;
         return APEX_NOERROR;
     });

examples/apex/apex_policy_engine_periodic.cpp

@@ -77,10 +77,10 @@ int hpx_main(hpx::program_options::variables_map& vm)
 
 void register_policy(void) {
     periodic_policy_handle =
-    apex::register_periodic_policy(1000, [](apex_context const& context) {
-        std::cout << "Periodic policy!" << std::endl;
-        return APEX_NOERROR;
-    });
+        apex::register_periodic_policy(1000, [](apex_context const&) {
+            std::cout << "Periodic policy!" << std::endl;
+            return APEX_NOERROR;
+        });
 }
 
 void deregister_policy(void) {

examples/balancing/hpx_thread_phase.cpp

@@ -46,13 +46,10 @@ typedef std::pair<thread_id_type, std::size_t> value_type;
 typedef std::vector<value_type> fifo_type;
 
 ///////////////////////////////////////////////////////////////////////////////
-void lock_and_wait(
-    mutex& m
-  , barrier& b0
-  , barrier& b1
-  , value_type& entry
-  , std::size_t wait
-) {
+void lock_and_wait(mutex& m, barrier& b0, barrier& b1, value_type& entry,
+    std::size_t /* wait */
+)
+{
     // Wait for all hpxthreads in this iteration to be created.
     b0.wait();
 

examples/jacobi/jacobi_component/row_range.hpp

@@ -27,8 +27,8 @@ namespace jacobi
         {}
 
         value_holder(std::size_t n, double init = 0.0)
-            : v_(n, 0.0)
-            , count_(0)
+          : v_(n, init)
+          , count_(0)
         {}
 
         double & operator[](std::size_t i)

examples/performance_counters/sine/sine.cpp

@@ -30,7 +30,7 @@ namespace performance_counters { namespace sine
 {
     ///////////////////////////////////////////////////////////////////////////
     // This function will be invoked whenever the implicit counter is queried.
-    std::int64_t immediate_sine(bool reset)
+    std::int64_t immediate_sine(bool)
     {
         static std::uint64_t started_at =
             hpx::chrono::high_resolution_clock::now();

examples/quickstart/channel_docs.cpp

@@ -50,7 +50,7 @@ void channel()
 //]
 
 ///////////////////////////////////////////////////////////////////////////////
-int main(int argc, char* argv[])
+int main()
 {
     channel();
 

examples/quickstart/customize_async.cpp

@@ -47,7 +47,7 @@ void run_with_high_priority()
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-int main(int argc, char* argv[])
+int main()
 {
     // run a thread on a large stack
     {

examples/quickstart/data_actions.cpp

@@ -27,7 +27,10 @@ struct plain_data
         hpx::components::set_component_type<plain_data<Action> >(type);
     }
 
-    static bool is_target_valid(hpx::naming::id_type const& id) { return true; }
+    static bool is_target_valid(hpx::naming::id_type const&)
+    {
+        return true;
+    }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -97,7 +100,7 @@ HPX_DEFINE_GET_COMPONENT_TYPE(plain_data<get_action>);
 HPX_DEFINE_GET_COMPONENT_TYPE(plain_data<set_action>);
 
 ///////////////////////////////////////////////////////////////////////////////
-int main(int argc, char* argv[])
+int main()
 {
     data = 0;
 

examples/quickstart/disable_thread_stealing_executor.cpp

@@ -123,7 +123,7 @@ int main()
         hpx::execution::par.executor());
 
     hpx::for_loop(
-        hpx::execution::par.on(exec), 0, v.size(), [](std::size_t i) {});
+        hpx::execution::par.on(exec), 0, v.size(), [](std::size_t) {});
 
     return 0;
 }