🚨 Updates for fixed clang-tidy

Author: elbeno

.github/workflows/unit_tests.yml

@@ -263,7 +263,7 @@ jobs:
           CC: "/usr/lib/llvm-${{env.DEFAULT_LLVM_VERSION}}/bin/clang"
           CXX: "/usr/lib/llvm-${{env.DEFAULT_LLVM_VERSION}}/bin/clang++"
           PR_TARGET_BRANCH: ${{ steps.target_branch.outputs.branch }}
-        run: cmake -B ${{github.workspace}}/build -DCMAKE_CXX_STANDARD=${{env.DEFAULT_CXX_STANDARD}} -DCPM_SOURCE_CACHE=~/cpm-cache
+        run: cmake -B ${{github.workspace}}/build -DCMAKE_CXX_STANDARD=17 -DCPM_SOURCE_CACHE=~/cpm-cache
 
       - name: Save CPM cache
         env:

include/stdx/atomic.hpp

@@ -13,6 +13,7 @@
 
 namespace stdx {
 inline namespace v1 {
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 template <typename T> class atomic {
     static_assert(std::is_trivially_copyable_v<T> and
                       std::is_copy_constructible_v<T> and
@@ -39,7 +40,7 @@ template <typename T> class atomic {
 
     constexpr atomic() CPP20(requires std::is_default_constructible_v<elem_t>)
         : value{} {}
-    constexpr atomic(T t) : value{static_cast<elem_t>(t)} {}
+    constexpr explicit atomic(T t) : value{static_cast<elem_t>(t)} {}
     atomic(atomic const &) = delete;
     auto operator=(atomic const &) -> atomic & = delete;
 
@@ -52,7 +53,9 @@ template <typename T> class atomic {
         ::atomic::store(value, static_cast<elem_t>(t), mo);
     }
 
+    // NOLINTNEXTLINE(google-explicit-constructor)
     [[nodiscard]] operator T() const { return load(); }
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     auto operator=(T t) -> T {
         store(t);
         return t;

include/stdx/atomic_bitset.hpp

@@ -102,6 +102,7 @@ class atomic_bitset {
         return static_cast<StorageElem>(salient_value(order));
     }
 
+    // NOLINTNEXTLINE(google-explicit-constructor)
     operator bitset_t() const {
         return bitset_t{salient_value(std::memory_order_seq_cst)};
     }

include/stdx/bit.hpp

@@ -19,7 +19,8 @@ inline namespace v1 {
 // endian
 
 #if __cpp_lib_endian < 201907L
-enum struct endian {
+// NOLINTNEXTLINE(performance-enum-size)
+enum struct endian : underlying_type_t<decltype(__BYTE_ORDER__)> {
     little = __ORDER_LITTLE_ENDIAN__,
     big = __ORDER_BIG_ENDIAN__,
     native = __BYTE_ORDER__
@@ -262,14 +263,14 @@ constexpr auto bit_pack = [](auto... args) {
 };
 
 template <>
-constexpr auto bit_pack<std::uint16_t> =
+constexpr inline auto bit_pack<std::uint16_t> =
     [](std::uint8_t hi, std::uint8_t lo) -> std::uint16_t {
     return static_cast<std::uint16_t>((static_cast<std::uint32_t>(hi) << 8u) |
                                       lo);
 };
 
 template <>
-constexpr auto bit_pack<std::uint32_t> =
+constexpr inline auto bit_pack<std::uint32_t> =
     stdx::overload{[](std::uint16_t hi, std::uint16_t lo) -> std::uint32_t {
                        return (static_cast<std::uint32_t>(hi) << 16u) | lo;
                    },
@@ -281,7 +282,7 @@ constexpr auto bit_pack<std::uint32_t> =
                    }};
 
 template <>
-constexpr auto bit_pack<std::uint64_t> =
+constexpr inline auto bit_pack<std::uint64_t> =
     stdx::overload{[](std::uint32_t hi, std::uint32_t lo) -> std::uint64_t {
                        return (static_cast<std::uint64_t>(hi) << 32u) | lo;
                    },

include/stdx/compiler.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+// NOLINTBEGIN(cppcoreguidelines-macro-usage)
+
 #ifndef CONSTINIT
 #ifndef __cpp_constinit
 #if defined(__clang__)
@@ -50,3 +52,5 @@
 #else
 #define STDX_PRAGMA(X) STDX_DO_PRAGMA(GCC X)
 #endif
+
+// NOLINTEND(cppcoreguidelines-macro-usage)

include/stdx/panic.hpp

@@ -31,6 +31,8 @@ auto panic(Args &&...args) -> void {
 } // namespace v1
 } // namespace stdx
 
+// NOLINTBEGIN(cppcoreguidelines-macro-usage)
+
 #if __cplusplus >= 202002L
 #define STDX_PANIC(MSG, ...)                                                   \
     [] {                                                                       \
@@ -40,3 +42,5 @@ auto panic(Args &&...args) -> void {
 #else
 #define STDX_PANIC(...) stdx::panic(__VA_ARGS__)
 #endif
+
+// NOLINTEND(cppcoreguidelines-macro-usage)

include/stdx/udls.hpp

@@ -84,6 +84,8 @@ operator""_Gi(unsigned long long int n) -> unsigned long long int {
     return n * 1'024ull * 1'024ull * 1'024ull;
 }
 
+// NOLINTBEGIN(cppcoreguidelines-macro-usage)
+
 #define STDX_SMALL_INT_LITERAL_DEF(x)                                          \
     CONSTEVAL auto operator""_##x(char const *, std::size_t)                   \
         ->std::integral_constant<std::size_t, x##u> {                          \
@@ -103,6 +105,8 @@ STDX_SMALL_INT_LITERAL_DEF(9)
 
 #undef STDX_SMALL_INT_LITERAL_DEF
 
+// NOLINTEND(cppcoreguidelines-macro-usage)
+
 // NOLINTEND(google-runtime-int)
 } // namespace literals
 

include/stdx/utility.hpp

@@ -78,7 +78,7 @@ template <typename T, typename U>
         if constexpr (t_is_const) {
             return std::as_const(u);
         } else {
-            return static_cast<U &>(u);
+            return (u);
         }
     } else {
         if constexpr (t_is_const) {
@@ -182,6 +182,8 @@ constexpr auto is_aligned_with = [](auto v) -> bool {
 } // namespace v1
 } // namespace stdx
 
+// NOLINTBEGIN(cppcoreguidelines-macro-usage)
+
 #ifndef FWD
 #define FWD(x) std::forward<decltype(x)>(x)
 #endif
@@ -217,3 +219,5 @@ constexpr auto is_aligned_with = [](auto v) -> bool {
         STDX_PRAGMA(diagnostic pop)                                            \
     }()
 #endif
+
+// NOLINTEND(cppcoreguidelines-macro-usage)