Merge pull request #882 from PowerGridModel/feature/clang-tidy

Cleanup clang tidy

Author: TonyXiang8787

.github/workflows/clang-tidy.yml

@@ -44,7 +44,7 @@ concurrency:
 
 jobs:
   clang-tidy:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     strategy:
       matrix:
         build-option: [ debug, release ]
@@ -60,10 +60,10 @@ jobs:
       - name: Install packages
         run: |
           sudo apt-get update
-          sudo apt-get install -y ninja-build clang-15 clang-tidy-15
-          sudo ln -s /usr/bin/clang-15 /usr/local/bin/clang
-          sudo ln -s /usr/bin/clang++-15 /usr/local/bin/clang++
-          sudo ln -s /usr/bin/clang-tidy-15 /usr/local/bin/clang-tidy
+          sudo apt-get install -y ninja-build clang-18 clang-tidy-18
+          sudo ln -s /usr/bin/clang-18 /usr/local/bin/clang
+          sudo ln -s /usr/bin/clang++-18 /usr/local/bin/clang++
+          sudo ln -s /usr/bin/clang-tidy-18 /usr/local/bin/clang-tidy
 
       - name: Enable brew
         run: |

docs/advanced_documentation/build-guide.md

@@ -210,7 +210,7 @@ export CXX=clang++-18            # or g++-13
 export CC=clang-18               # gcc-13
 export CMAKE_PREFIX_PATH=/home/linuxbrew/.linuxbrew
 export LLVM_COV=llvm-cov-18
-export CLANG_TIDY=clang-tidy-15  # only if you want to use one of the clang-tidy presets
+export CLANG_TIDY=clang-tidy-18  # only if you want to use one of the clang-tidy presets
 ```
 
 ### Ubuntu Software Packages

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/deserializer.hpp

@@ -44,7 +44,7 @@ using nlohmann::json;
 // visitor for json conversion
 struct JsonMapArrayData {
     size_t size{};
-    msgpack::sbuffer buffer{};
+    msgpack::sbuffer buffer;
 };
 
 struct JsonSAXVisitor {
@@ -130,8 +130,8 @@ struct JsonSAXVisitor {
         throw SerializationError{ss.str()};
     }
 
-    std::stack<JsonMapArrayData> data_buffers{};
-    msgpack::sbuffer root_buffer{};
+    std::stack<JsonMapArrayData> data_buffers;
+    msgpack::sbuffer root_buffer;
 };
 
 // visitors for parsing
@@ -192,8 +192,15 @@ struct MapArrayVisitor : DefaultErrorVisitor<MapArrayVisitor<map_array>> {
         std::same_as<map_array, visit_map_t> || std::same_as<map_array, visit_map_array_t>;
     static constexpr bool enable_array =
         std::same_as<map_array, visit_array_t> || std::same_as<map_array, visit_map_array_t>;
-    static constexpr std::string_view static_err_msg =
-        enable_map ? (enable_array ? "Map or an array expected." : "Map expected.") : "Array expected.";
+    static constexpr std::string_view static_err_msg = [] {
+        if constexpr (enable_map && enable_array) {
+            return "Map or an array expected.";
+        } else if constexpr (enable_map) {
+            return "Map expected.";
+        } else {
+            return "Array expected.";
+        }
+    }();
 
     Idx size{};
     bool is_map{};
@@ -228,7 +235,7 @@ struct MapArrayVisitor : DefaultErrorVisitor<MapArrayVisitor<map_array>> {
 struct StringVisitor : DefaultErrorVisitor<StringVisitor> {
     static constexpr std::string_view static_err_msg = "String expected.";
 
-    std::string_view str{};
+    std::string_view str;
     bool visit_str(const char* v, uint32_t size) {
         str = {v, size};
         return true;

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/serializer.hpp

@@ -76,10 +76,10 @@ struct MapArray {
 struct JsonConverter : msgpack::null_visitor {
     static constexpr char sep_char = ' ';
 
-    Idx indent;
-    Idx max_indent_level;
-    std::stringstream ss{};
-    std::stack<MapArray> map_array{};
+    Idx indent{};
+    Idx max_indent_level{};
+    std::stringstream ss{};           // NOLINT(readability-redundant-member-init)
+    std::stack<MapArray> map_array{}; // NOLINT(readability-redundant-member-init)
 
     void print_indent() {
         if (indent < 0) {
@@ -293,7 +293,7 @@ class Serializer {
     std::vector<ComponentBuffer> component_buffers_; // list of components, then all scenario flatten
 
     // msgpack pakcer
-    msgpack::sbuffer msgpack_buffer_{};
+    msgpack::sbuffer msgpack_buffer_;
     msgpack::packer<msgpack::sbuffer> packer_;
     bool use_compact_list_{};
     std::map<MetaComponent const*, std::vector<MetaAttribute const*>> attributes_;
@@ -506,12 +506,10 @@ class Serializer {
     }
 
     void pack_element_in_list(columnar_t /*tag*/, BufferView const& element_buffer, MetaComponent const& /*component*/,
-                              std::span<MetaAttribute const* const> attributes) {
+                              [[maybe_unused]] std::span<MetaAttribute const* const> attributes) {
         assert(is_columnar(element_buffer));
         assert(element_buffer.reordered_attribute_buffers.size() == attributes.size());
 
-        (void)attributes; // suppress unused variable in release mode
-
         pack_array(element_buffer.reordered_attribute_buffers.size());
         for (auto const& attribute_buffer : element_buffer.reordered_attribute_buffers) {
             if (check_nan(attribute_buffer, element_buffer.idx)) {
@@ -606,7 +604,7 @@ class Serializer {
         });
     }
     void pack_attribute(AttributeBuffer<void const> const& attribute_buffer, Idx idx) {
-        return ctype_func_selector(attribute_buffer.meta_attribute->ctype, [&]<class T> {
+        ctype_func_selector(attribute_buffer.meta_attribute->ctype, [this, &attribute_buffer, idx]<class T> {
             packer_.pack(*(reinterpret_cast<T const*>(attribute_buffer.data) + idx));
         });
     }

power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp

@@ -54,7 +54,7 @@ template <symmetry_tag sym_type> struct BranchShortCircuitSolverOutput {
 
 // fault math calculation parameters and math output
 struct FaultCalcParam {
-    DoubleComplex y_fault{};
+    DoubleComplex y_fault;
     FaultType fault_type{};
     FaultPhase fault_phase{};
 };
@@ -126,7 +126,7 @@ static_assert(sensor_calc_param_type<PowerSensorCalcParam<asymmetric_t>>);
 struct TransformerTapRegulatorCalcParam {
     double u_set{};
     double u_band{};
-    DoubleComplex z_compensation{};
+    DoubleComplex z_compensation;
     IntS status{};
 };
 
@@ -193,7 +193,7 @@ struct SourceCalcParam {
     DoubleComplex y1;
     DoubleComplex y0;
 
-    template <symmetry_tag sym> inline ComplexTensor<sym> y_ref() const {
+    template <symmetry_tag sym> ComplexTensor<sym> y_ref() const {
         if constexpr (is_symmetric_v<sym>) {
             return y1;
         } else {

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

@@ -91,9 +91,20 @@ using IntSVector = std::vector<IntS>;
 template <class T, class... Ts>
 concept is_in_list_c = (std::same_as<std::remove_const_t<T>, Ts> || ...);
 
+namespace capturing {
+// perfect forward into void
+template <class... T>
+constexpr void into_the_void(T&&... /*ignored*/) { // NOLINT(cppcoreguidelines-missing-std-forward)
+    // do nothing; the constexpr allows all compilers to optimize this away
+}
+} // namespace capturing
+
 // functor to include all
 struct IncludeAll {
-    template <class... T> constexpr bool operator()(T&&... /*ignored*/) const { return true; }
+    template <class... T> consteval bool operator()(T&&... args) const {
+        capturing::into_the_void(std::forward<T>(args)...);
+        return true;
+    }
 };
 constexpr IncludeAll include_all{};
 

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

@@ -161,7 +161,7 @@ class DenseGroupedIdxVector {
 
         IdxVector const* dense_vector_{};
         Idx group_{};
-        std::pair<group_iterator, group_iterator> group_range_{};
+        std::pair<group_iterator, group_iterator> group_range_;
 
         friend class boost::iterator_core_access;
 

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

@@ -16,14 +16,14 @@ concept iterator_like = requires(T const t) {
 
 template <typename T, typename ElementType>
 concept forward_iterator_like = std::regular<T> && iterator_like<T, ElementType> && requires(T t) {
-    { t++ } -> std::same_as<T>;
-    { ++t } -> std::same_as<T&>;
+    { t++ } -> std::same_as<T>;  // NOLINT(bugprone-inc-dec-in-conditions)
+    { ++t } -> std::same_as<T&>; // NOLINT(bugprone-inc-dec-in-conditions)
 };
 
 template <typename T, typename ElementType>
 concept bidirectional_iterator_like = forward_iterator_like<T, ElementType> && requires(T t) {
-    { t-- } -> std::same_as<T>;
-    { --t } -> std::same_as<T&>;
+    { t-- } -> std::same_as<T>;  // NOLINT(bugprone-inc-dec-in-conditions)
+    { --t } -> std::same_as<T&>; // NOLINT(bugprone-inc-dec-in-conditions)
 };
 
 template <typename T, typename ElementType>

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

@@ -281,7 +281,7 @@ inline void add_diag(Eigen::ArrayBase<DerivedA>& x, Eigen::ArrayBase<DerivedB> c
 }
 template <rk2_tensor DerivedA, column_vector DerivedB>
 inline void add_diag(Eigen::ArrayBase<DerivedA>&& x, Eigen::ArrayBase<DerivedB> const& y) {
-    x.matrix().diagonal() += y.matrix();
+    std::move(x).matrix().diagonal() += y.matrix();
 }
 
 // zero tensor
@@ -348,17 +348,22 @@ inline auto all_zero(RealValue<asymmetric_t> const& value) { return (value == Re
 //
 // The function assumes that the current value is normalized and new value should be normalized with scalar
 template <symmetry_tag sym, class Proxy>
-inline void update_real_value(RealValue<sym> const& new_value, Proxy&& current_value, double scalar) {
+inline void
+update_real_value(RealValue<sym> const& new_value, Proxy&& current_value,
+                  double scalar) { // NOLINT(cppcoreguidelines-missing-std-forward) // perfect forward into void
     if constexpr (is_symmetric_v<sym>) {
         if (!is_nan(new_value)) {
-            current_value = scalar * new_value;
+            std::forward<Proxy>(current_value) = scalar * new_value;
+        } else {
+            capturing::into_the_void<Proxy>(std::forward<Proxy>(current_value));
         }
     } else {
         for (size_t i = 0; i != 3; ++i) {
             if (!is_nan(new_value(i))) {
-                current_value(i) = scalar * new_value(i);
+                current_value(i) = scalar * new_value(i); // can't forward due to runtime element access
             }
         }
+        capturing::into_the_void<Proxy>(std::forward<Proxy>(current_value));
     }
 }
 

power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp

@@ -193,7 +193,7 @@ class Fault final : public Base {
     double r_f_;
     double x_f_;
 
-    void check_sanity() {
+    void check_sanity() const {
         using enum FaultPhase;
 
         auto const check_supported = [&](auto const& iterable) {
@@ -203,15 +203,19 @@ class Fault final : public Base {
         };
         switch (fault_type_) {
         case FaultType::three_phase:
-            return check_supported(std::array{FaultPhase::nan, default_value, abc});
+            check_supported(std::array{FaultPhase::nan, default_value, abc});
+            return;
         case FaultType::single_phase_to_ground:
-            return check_supported(std::array{FaultPhase::nan, default_value, a, b, c});
+            check_supported(std::array{FaultPhase::nan, default_value, a, b, c});
+            return;
         case FaultType::two_phase:
             [[fallthrough]];
         case FaultType::two_phase_to_ground:
-            return check_supported(std::array{FaultPhase::nan, default_value, ab, ac, bc});
+            check_supported(std::array{FaultPhase::nan, default_value, ab, ac, bc});
+            return;
         case FaultType::nan:
-            return check_supported(std::array{FaultPhase::nan, default_value, abc, a, b, c, ab, ac, bc});
+            check_supported(std::array{FaultPhase::nan, default_value, abc, a, b, c, ab, ac, bc});
+            return;
         default:
             throw InvalidShortCircuitType(fault_type_);
         }