Remove excessive and wrong use of std::forward (WIP)

.clang-tidy

@@ -66,6 +66,7 @@ readability-*,
 -readability-redundant-member-init,
 -readability-uppercase-literal-suffix,
 -bugprone-unchecked-optional-access,
+-cppcoreguidelines-missing-std-forward,
 '
 
 WarningsAsErrors: '*'

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp

@@ -556,11 +556,11 @@ template <dataset_type_tag dataset_type_> class Dataset {
     template <class type_getter, class ComponentType, typename Func,
               class StructType = DataStruct<typename type_getter::template type<ComponentType>>>
         requires std::invocable<Func, SpanRange<StructType>> && std::invocable<Func, RangeObject<StructType>>
-    auto for_each_component(Func&& func, Idx scenario = invalid_index) const {
+    auto for_each_component(Func func, Idx scenario = invalid_index) const {
         if (is_columnar(ComponentType::name)) {
-            return std::forward<Func>(func)(get_columnar_buffer_span<type_getter, ComponentType, StructType>(scenario));
+            return func(get_columnar_buffer_span<type_getter, ComponentType, StructType>(scenario));
         }
-        return std::forward<Func>(func)(get_buffer_span<type_getter, ComponentType, StructType>(scenario));
+        return func(get_buffer_span<type_getter, ComponentType, StructType>(scenario));
     }
 
     void set_next_cartesian_product_dimension(Dataset const* next) {

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp

@@ -51,18 +51,18 @@ template <class T> constexpr CType ctype_v = ctype_t<T>::value;
 // function selector based on ctype
 // the operator() of the functor should have a single template parameter
 // the selector will instantiate the operator() with relevant type
-template <class Functor, class... Args> decltype(auto) ctype_func_selector(CType ctype, Functor&& f, Args&&... args) {
+template <class Functor, class... Args> decltype(auto) ctype_func_selector(CType ctype, Functor f, Args&&... args) {
     using enum CType;
 
     switch (ctype) {
     case c_double:
-        return std::forward<Functor>(f).template operator()<double>(std::forward<Args>(args)...);
+        return f.template operator()<double>(std::forward<Args>(args)...);
     case c_double3:
-        return std::forward<Functor>(f).template operator()<RealValue<asymmetric_t>>(std::forward<Args>(args)...);
+        return f.template operator()<RealValue<asymmetric_t>>(std::forward<Args>(args)...);
     case c_int8:
-        return std::forward<Functor>(f).template operator()<int8_t>(std::forward<Args>(args)...);
+        return f.template operator()<int8_t>(std::forward<Args>(args)...);
     case c_int32:
-        return std::forward<Functor>(f).template operator()<int32_t>(std::forward<Args>(args)...);
+        return f.template operator()<int32_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"CType selector", ctype};
     }

power_grid_model_c/power_grid_model/include/power_grid_model/calculation.hpp

@@ -27,54 +27,52 @@ template <typename T>
 concept calculation_type_tag = std::derived_from<T, calculation_type_t>;
 
 template <class Functor, class... Args>
-decltype(auto) calculation_symmetry_func_selector(CalculationSymmetry calculation_symmetry, Functor&& f,
-                                                  Args&&... args) {
+decltype(auto) calculation_symmetry_func_selector(CalculationSymmetry calculation_symmetry, Functor f, Args&&... args) {
     using enum CalculationSymmetry;
 
     switch (calculation_symmetry) {
     case symmetric:
-        return std::forward<Functor>(f).template operator()<symmetric_t>(std::forward<Args>(args)...);
+        return f.template operator()<symmetric_t>(std::forward<Args>(args)...);
     case asymmetric:
-        return std::forward<Functor>(f).template operator()<asymmetric_t>(std::forward<Args>(args)...);
+        return f.template operator()<asymmetric_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"Calculation symmetry selector", calculation_symmetry};
     }
 }
 
 template <class Functor, class... Args>
-decltype(auto) calculation_type_func_selector(CalculationType calculation_type, Functor&& f, Args&&... args) {
+decltype(auto) calculation_type_func_selector(CalculationType calculation_type, Functor f, Args&&... args) {
     using enum CalculationType;
 
     switch (calculation_type) {
     case CalculationType::power_flow:
-        return std::forward<Functor>(f).template operator()<power_flow_t>(std::forward<Args>(args)...);
+        return f.template operator()<power_flow_t>(std::forward<Args>(args)...);
     case CalculationType::state_estimation:
-        return std::forward<Functor>(f).template operator()<state_estimation_t>(std::forward<Args>(args)...);
+        return f.template operator()<state_estimation_t>(std::forward<Args>(args)...);
     case CalculationType::short_circuit:
-        return std::forward<Functor>(f).template operator()<short_circuit_t>(std::forward<Args>(args)...);
+        return f.template operator()<short_circuit_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"CalculationType", calculation_type};
     }
 }
 
 template <class Functor, class... Args>
 decltype(auto) calculation_type_symmetry_func_selector(CalculationType calculation_type,
-                                                       CalculationSymmetry calculation_symmetry, Functor&& f,
+                                                       CalculationSymmetry calculation_symmetry, Functor f,
                                                        Args&&... args) {
     calculation_type_func_selector(
         calculation_type,
         []<calculation_type_tag calculation_type, typename Functor_, typename... Args_>(
-            CalculationSymmetry calculation_symmetry_, Functor_&& f_, Args_&&... args_) {
+            CalculationSymmetry calculation_symmetry_, Functor_ f_, Args_&&... args_) {
             calculation_symmetry_func_selector(
                 calculation_symmetry_,
-                []<symmetry_tag sym, typename SubFunctor, typename... SubArgs>(SubFunctor&& sub_f,
+                []<symmetry_tag sym, typename SubFunctor, typename... SubArgs>(SubFunctor sub_f,
                                                                                SubArgs&&... sub_args) {
-                    std::forward<SubFunctor>(sub_f).template operator()<calculation_type, sym>(
-                        std::forward<SubArgs>(sub_args)...);
+                    sub_f.template operator()<calculation_type, sym>(std::forward<SubArgs>(sub_args)...);
                 },
-                std::forward<Functor_>(f_), std::forward<Args_>(args_)...);
+                f_, std::forward<Args_>(args_)...);
         },
-        calculation_symmetry, std::forward<Functor>(f), std::forward<Args>(args)...);
+        calculation_symmetry, f, std::forward<Args>(args)...);
 }
 
 template <typename T, typename sym> struct Calculator;

power_grid_model_c/power_grid_model/include/power_grid_model/common/calculation_info.hpp

@@ -36,10 +36,8 @@ class CalculationInfo : public Logger {
     void log(LogEvent tag, double value) override { log_impl(tag, value); }
     void log(LogEvent tag, Idx value) override { log_impl(tag, static_cast<double>(value)); }
     void log(std::string_view /*message*/) const { /* ignore all such events for now */ }
-    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn&& fn) const {
-        capturing::into_the_void(std::forward<Fn>(fn));
-    }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) const { capturing::into_the_void(std::forward<Fn>(fn)); }
+    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn fn) const { capturing::into_the_void(fn); }
+    template <LazyLoggingFn Fn> void log(Fn fn) const { capturing::into_the_void(fn); }
 
   private:
     Data data_;

power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp

@@ -102,18 +102,14 @@ concept derives_from_any_in_list_c = (std::derived_from<T, Ts> || ...);
 
 namespace capturing {
 // perfect forward into void
-template <class... T>
-constexpr void into_the_void(T&&... /*ignored*/) { // NOLINT(cppcoreguidelines-missing-std-forward)
+template <class... T> constexpr void into_the_void(T&&... /*ignored*/) {
     // do nothing; the constexpr allows all compilers to optimize this away
 }
 } // namespace capturing
 
 // functor to include all
 struct IncludeAll {
-    template <class... T> consteval bool operator()(T&&... args) const {
-        capturing::into_the_void(std::forward<T>(args)...);
-        return true;
-    }
+    template <class... T> consteval bool operator()(T&&... /* args */) const { return true; }
 };
 constexpr IncludeAll include_all{};
 

power_grid_model_c/power_grid_model/include/power_grid_model/common/dummy_logging.hpp

@@ -20,10 +20,8 @@ class NoLogger : public Logger {
     void log(LogEvent /*tag*/, double /*value*/) override { /* no logging */ }
     void log(LogEvent /*tag*/, Idx /*value*/) override { /* no logging */ }
     void log(std::string_view /*message*/) const { /* no logging */ }
-    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn&& fn) const {
-        capturing::into_the_void(std::forward<Fn>(fn));
-    }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) const { capturing::into_the_void(std::forward<Fn>(fn)); }
+    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn fn) const { capturing::into_the_void(fn); }
+    template <LazyLoggingFn Fn> void log(Fn fn) const { capturing::into_the_void(fn); }
     template <std::derived_from<Logger> T> T& merge_into(T& destination) const { return destination; }
 };
 

power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp

@@ -37,9 +37,9 @@
 
 namespace detail {
 template <std::ranges::viewable_range ElementGroups>
 constexpr auto sparse_encode(ElementGroups&& element_groups, Idx num_groups) {
     IdxVector result(num_groups + 1);
-    auto element_groups_view = std::views::all(std::forward<ElementGroups>(element_groups));
+    auto element_groups_view = std::views::all(element_groups);
     auto next_group = std::begin(element_groups_view);
     for (auto const group : IdxRange{num_groups}) {
         next_group = std::upper_bound(next_group, std::end(element_groups_view), group);
@@ -48,8 +48,8 @@
     return result;
 }
 
 template <std::ranges::viewable_range IndPtr> constexpr auto sparse_decode(IndPtr&& indptr) {
-    auto indptr_view = std::views::all(std::forward<IndPtr>(indptr));
+    auto indptr_view = std::views::all(indptr);
     auto result = IdxVector(indptr_view.back());
     for (Idx const group : IdxRange{static_cast<Idx>(indptr_view.size()) - 1}) {
         std::fill(std::begin(result) + indptr_view[group], std::begin(result) + indptr_view[group + 1], group);

power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_facade.hpp

@@ -35,9 +35,7 @@
   public:
     using iterator_category = std::random_access_iterator_tag;
 
-    template <typename Self> constexpr decltype(auto) operator->(this Self&& self) {
-        return &(*std::forward<Self>(self));
-    }
+    template <typename Self> constexpr decltype(auto) operator->(this Self&& self) { return &(*self); }
 
     template <typename Self, typename Other>
         requires std::same_as<std::remove_cvref_t<Self>, std::remove_cvref_t<Other>>
@@ -94,12 +92,12 @@
     template <typename Self, std::integral Int>
         requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
     friend constexpr std::remove_cvref_t<Self> operator+(Int offset, Self&& self) {
-        return std::forward<Self>(self) + offset;
+        return self + offset;
     }
     template <typename Self, std::integral Int>
         requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
     friend constexpr std::remove_cvref_t<Self> operator-(Self&& self, Int idx) {
-        return (std::forward<Self>(self)) + (-idx);
+        return self + (-idx);
     }
 
     template <typename Self>

power_grid_model_c/power_grid_model/include/power_grid_model/common/logging.hpp

@@ -56,8 +56,8 @@ class Logger {
     virtual void log(LogEvent tag, Idx value) = 0;
 
     void log(std::string_view message) { log(LogEvent::unknown, message); }
-    template <LazyLoggingFn Fn> void log(LogEvent tag, Fn&& fn) { log(tag, std::invoke(std::forward<Fn>(fn))); }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) { log(LogEvent::unknown, std::invoke(std::forward<Fn>(fn))); }
+    template <LazyLoggingFn Fn> void log(LogEvent tag, Fn fn) { log(tag, std::invoke(fn)); }
+    template <LazyLoggingFn Fn> void log(Fn fn) { log(LogEvent::unknown, std::invoke(fn)); }
 
     Logger(Logger&&) noexcept = default;
     Logger& operator=(Logger&&) noexcept = default;

power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp

@@ -335,8 +335,9 @@
     x.matrix().diagonal() += y.matrix();
 }
 template <rk2_tensor DerivedA, column_vector DerivedB>
+// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
 inline void add_diag(Eigen::ArrayBase<DerivedA>&& x, Eigen::ArrayBase<DerivedB> const& y) {
-    std::move(x).matrix().diagonal() += y.matrix();
+    x.matrix().diagonal() += y.matrix();
 }
 
 // zero tensor
@@ -408,17 +409,14 @@
 inline void update_real_value(RealValue<sym> const& new_value, Proxy&& current_value, RealValue<symmetric_t> scalar) {
     if constexpr (is_symmetric_v<sym>) {
         if (!is_nan(new_value)) {
-            std::forward<Proxy>(current_value) = scalar * new_value;
-        } else {
-            capturing::into_the_void<Proxy>(std::forward<Proxy>(current_value));
+            current_value = scalar * new_value;
         }
     } else {
         for (size_t i = 0; i != 3; ++i) {
             if (!is_nan(new_value(i))) {
-                current_value(i) = scalar * new_value(i); // can't forward due to runtime element access
+                current_value(i) = scalar * new_value(i);
             }
         }
-        capturing::into_the_void<Proxy>(std::forward<Proxy>(current_value));
     }
 }
 

power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -17,53 +17,53 @@
   public:
     // the multiple  NOSONARs are used to avoid the complaints about the unnamed concepts
     template <typename Self, typename ResultDataset>
     void calculate(this Self&& self, ResultDataset const& result_data, Idx pos, Logger& logger)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).calculate_impl(result_data, pos, logger) } -> std::same_as<void>;
+            { self.calculate_impl(result_data, pos, logger) } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).calculate_impl(result_data, pos, logger);
+        return self.calculate_impl(result_data, pos, logger);
     }
 
     template <typename Self, typename ResultDataset>
     void calculate(this Self&& self, ResultDataset const& result_data, Logger& logger) {
-        std::forward<Self>(self).calculate(result_data, Idx{}, logger);
+        self.calculate(result_data, Idx{}, logger);
     }
 
     template <typename Self>
     void cache_calculate(this Self&& self, Logger& logger)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).cache_calculate_impl(logger) } -> std::same_as<void>;
+            { self.cache_calculate_impl(logger) } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).cache_calculate_impl(logger);
+        return self.cache_calculate_impl(logger);
     }
 
     template <typename Self, typename UpdateDataset>
     void prepare_job_dispatch(this Self&& self, UpdateDataset const& update_data)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).prepare_job_dispatch_impl(update_data) } -> std::same_as<void>;
+            { self.prepare_job_dispatch_impl(update_data) } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).prepare_job_dispatch_impl(update_data);
+        return self.prepare_job_dispatch_impl(update_data);
     }
 
     template <typename Self, typename UpdateDataset>
     void setup(this Self&& self, UpdateDataset const& update_data, Idx scenario_idx)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).setup_impl(update_data, scenario_idx) } -> std::same_as<void>;
+            { self.setup_impl(update_data, scenario_idx) } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).setup_impl(update_data, scenario_idx);
+        return self.setup_impl(update_data, scenario_idx);
     }
 
     template <typename Self>
     void winddown(this Self&& self)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).winddown_impl() } -> std::same_as<void>;
+            { self.winddown_impl() } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).winddown_impl();
+        return self.winddown_impl();
     }
 
   protected:

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/core_utils.hpp

@@ -16,25 +16,22 @@ namespace power_grid_model::main_core::utils {
 namespace detail {
 
 template <typename Tuple, class Functor, std::size_t... Indices>
-constexpr void run_functor_with_tuple_index_return_void(Functor&& functor, std::index_sequence<Indices...> /*unused*/) {
+constexpr void run_functor_with_tuple_index_return_void(Functor functor, std::index_sequence<Indices...> /*unused*/) {
     if constexpr (sizeof...(Indices) == 1) {
-        (std::forward<Functor>(functor).template operator()<std::tuple_element_t<Indices, Tuple>>(), ...);
+        (functor.template operator()<std::tuple_element_t<Indices, Tuple>>(), ...);
     } else {
         (functor.template operator()<std::tuple_element_t<Indices, Tuple>>(), ...);
-        capturing::into_the_void(std::forward<Functor>(functor));
+        capturing::into_the_void(functor);
     }
 }
 
 template <typename Tuple, class Functor, std::size_t... Indices>
-constexpr auto run_functor_with_tuple_index_return_array(Functor&& functor,
-                                                         std::index_sequence<Indices...> /*unused*/) {
+constexpr auto run_functor_with_tuple_index_return_array(Functor functor, std::index_sequence<Indices...> /*unused*/) {
     if constexpr (sizeof...(Indices) == 1) {
-        return std::array {
-            std::forward<Functor>(functor).template operator()<std::tuple_element_t<Indices, Tuple>>()...
-        };
+        return std::array { functor.template operator()<std::tuple_element_t<Indices, Tuple>>()... };
     } else {
         auto result = std::array { functor.template operator()<std::tuple_element_t<Indices, Tuple>>()... };
-        capturing::into_the_void(std::forward<Functor>(functor));
+        capturing::into_the_void(functor);
         return result;
     }
 }
@@ -44,14 +41,14 @@ constexpr auto run_functor_with_tuple_index_return_array(Functor&& functor,
 constexpr Idx sequential{-1};
 constexpr Idx invalid_index{-1};
 
-template <typename Tuple, class Functor> constexpr void run_functor_with_tuple_return_void(Functor&& functor) {
-    detail::run_functor_with_tuple_index_return_void<Tuple>(std::forward<Functor>(functor),
+template <typename Tuple, class Functor> constexpr void run_functor_with_tuple_return_void(Functor functor) {
+    detail::run_functor_with_tuple_index_return_void<Tuple>(functor,
                                                             std::make_index_sequence<std::tuple_size_v<Tuple>>{});
 }
 
-template <typename Tuple, class Functor> constexpr auto run_functor_with_tuple_return_array(Functor&& functor) {
+template <typename Tuple, class Functor> constexpr auto run_functor_with_tuple_return_array(Functor functor) {
     return detail::run_functor_with_tuple_index_return_array<Tuple>(
-        std::forward<Functor>(functor), std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+        functor, std::make_index_sequence<std::tuple_size_v<Tuple>>{});
 }
 
 } // namespace power_grid_model::main_core::utils

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/input.hpp

@@ -48,7 +48,7 @@
 // different selection based on component type
 template <std::derived_from<Base> Component, class ComponentContainer, std::ranges::viewable_range Inputs>
     requires common::component_container_c<ComponentContainer, Component>
 inline void add_component(ComponentContainer& components, Inputs&& component_inputs, double system_frequency) {
     using ComponentView =
         std::conditional_t<std::same_as<std::ranges::range_reference_t<Inputs>, typename Component::InputType const&>,
                            typename Component::InputType const&, typename Component::InputType>;
@@ -58,7 +58,7 @@
     std::vector<Idx2D> regulated_objects;
     // loop to add component
 
-    for (auto const& input_proxy : std::views::all(std::forward<Inputs>(component_inputs))) {
+    for (auto const& input_proxy : std::views::all(component_inputs)) {
         ComponentView const input = [&input_proxy]() -> ComponentView { return input_proxy; }();
 
         ID const id = input.id;