🚨 Fix clang-tidy issues

Author: elbeno

include/cib/detail/config_item.hpp

@@ -4,11 +4,11 @@
 
 namespace cib::detail {
 struct config_item {
-    [[nodiscard]] constexpr auto extends_tuple() const -> stdx::tuple<> {
+    [[nodiscard]] constexpr static auto extends_tuple() -> stdx::tuple<> {
         return {};
     }
 
-    [[nodiscard]] constexpr auto exports_tuple() const -> stdx::tuple<> {
+    [[nodiscard]] constexpr static auto exports_tuple() -> stdx::tuple<> {
         return {};
     }
 };

include/flow/graph_builder.hpp

@@ -297,7 +297,8 @@ struct graph_builder {
         constexpr static auto run() { built()(); }
 
       public:
-        constexpr operator FunctionPtr() const { return run; }
+        // NOLINTNEXTLINE(google-explicit-constructor)
+        constexpr explicit(false) operator FunctionPtr() const { return run; }
         constexpr auto operator()() const -> void { run(); }
         constexpr static bool active = decltype(built())::active;
     };

include/flow/graphviz_builder.hpp

@@ -61,7 +61,10 @@ struct graphviz_builder {
         static auto run() -> std::string { return built(); }
 
       public:
-        constexpr operator VizFunctionPtr() const { return run; }
+        // NOLINTNEXTLINE(google-explicit-constructor)
+        constexpr explicit(false) operator VizFunctionPtr() const {
+            return run;
+        }
         auto operator()() const -> std::string { return run(); }
         constexpr static bool active = true;
     };

include/interrupt/dynamic_controller.hpp

@@ -10,11 +10,12 @@
 #include <boost/mp11/algorithm.hpp>
 #include <boost/mp11/list.hpp>
 
+#include <cstdint>
 #include <limits>
 #include <type_traits>
 
 namespace interrupt {
-enum class resource_status { OFF = 0, ON = 1 };
+enum class resource_status : std::uint8_t { OFF, ON };
 
 template <typename Irq>
 concept has_enable_field = requires { Irq::enable_field; };

include/log/catalog/mipi_encoder.hpp

@@ -16,9 +16,8 @@
 #include <cstdint>
 #include <utility>
 
-template <auto...> struct undef;
-
-namespace {
+namespace logging::mipi {
+namespace detail {
 template <logging::level L, typename S, typename T>
 constexpr auto to_message() {
     constexpr auto s = S::value;
@@ -46,9 +45,8 @@ template <typename S> constexpr auto to_module() {
         return sc::module_string<sc::undefined<void, char_t, s[Is]...>>{};
     }(std::make_integer_sequence<std::size_t, std::size(s)>{});
 }
-} // namespace
+} // namespace detail
 
-namespace logging::mipi {
 namespace defn {
 using msg::at;
 using msg::dword_index_t;
@@ -125,8 +123,8 @@ template <typename TDestinations> struct log_handler {
     template <logging::level Level, typename ModuleId, typename Msg>
     ALWAYS_INLINE auto log_msg(Msg msg) -> void {
         msg.apply([&]<typename StringType>(StringType, auto... args) {
-            using Message = decltype(to_message<Level>(msg));
-            using Module = decltype(to_module<ModuleId>());
+            using Message = decltype(detail::to_message<Level>(msg));
+            using Module = decltype(detail::to_module<ModuleId>());
             dispatch_message<Level>(catalog<Message>(), module<Module>(),
                                     static_cast<std::uint32_t>(args)...);
         });

include/log/log.hpp

@@ -62,6 +62,8 @@ template <stdx::ct_string S> struct module_id_t {
 
 using cib_log_module_id_t = typename logging::module_id_t<"default">::type;
 
+// NOLINTBEGIN(cppcoreguidelines-macro-usage)
+
 #define CIB_DO_PRAGMA(X) _Pragma(#X)
 #ifdef __clang__
 #define CIB_PRAGMA(X) CIB_DO_PRAGMA(clang X)
@@ -118,3 +120,5 @@ template <typename Flavor, typename... Ts> static auto log_version() -> void {
 
 #define CIB_LOG_V(FLAVOR) logging::log_version<FLAVOR>()
 #define CIB_LOG_VERSION() CIB_LOG_V(logging::default_flavor_t)
+
+// NOLINTEND(cppcoreguidelines-macro-usage)

include/match/predicate.hpp

@@ -15,9 +15,8 @@ template <stdx::ct_string Name, stdx::callable P> struct predicate_t {
 
     constexpr static P pred{};
 
-    constexpr predicate_t(P) {}
-
-    constexpr predicate_t() {}
+    constexpr predicate_t() = default;
+    constexpr explicit(true) predicate_t(P) {}
 
     [[nodiscard]] constexpr auto
     operator()(auto const &event) const -> decltype(pred(event)) {
@@ -34,7 +33,7 @@ template <stdx::ct_string Name, stdx::callable P> struct predicate_t {
 };
 
 template <stdx::ct_string Name = "<predicate>", stdx::callable P>
-constexpr auto predicate(P &&p) -> predicate_t<Name, std::remove_cvref_t<P>> {
-    return {std::forward<P>(p)};
+constexpr auto predicate(P &&p) {
+    return predicate_t<Name, std::remove_cvref_t<P>>{std::forward<P>(p)};
 }
 } // namespace match

include/msg/message.hpp

@@ -127,7 +127,7 @@ template <typename Name, typename T> struct field_value {
 template <typename Name> struct field_name {
     using name_t = Name;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature)
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     template <typename T> constexpr auto operator=(T value) {
         return field_value<Name, T>{value};
     }
@@ -369,6 +369,7 @@ template <stdx::ct_string Name, typename... Fields> struct message {
         using span_t = Span;
 
         template <detail::storage_like S>
+        // NOLINTNEXTLINE(google-explicit-constructor)
         explicit(false) view_t(S const &s) : storage{s} {}
 
         template <detail::storage_like S, some_field_value... Vs>
@@ -377,6 +378,7 @@ template <stdx::ct_string Name, typename... Fields> struct message {
         }
 
         template <typename S>
+        // NOLINTNEXTLINE(google-explicit-constructor)
         constexpr explicit(false) view_t(owner_t<S> const &s LIFETIMEBOUND)
             : storage{s.data()} {}
 
@@ -391,6 +393,7 @@ template <stdx::ct_string Name, typename... Fields> struct message {
                      std::same_as<std::add_const_t<typename S::element_type>,
                                   typename span_t::element_type> and
                      span_t::extent <= S::extent)
+        // NOLINTNEXTLINE(google-explicit-constructor)
         constexpr explicit(false) view_t(view_t<S> const &s)
             : storage{s.data()} {}
 

include/seq/impl.hpp

@@ -8,10 +8,11 @@
 
 #include <array>
 #include <cstddef>
+#include <cstdint>
 #include <iterator>
 
 namespace seq {
-enum struct direction { FORWARD = 0, BACKWARD = 1 };
+enum struct direction : std::uint8_t { FORWARD, BACKWARD };
 
 template <stdx::ct_string, std::size_t NumSteps> struct impl {
     stdx::cx_vector<func_ptr, NumSteps> _forward_steps{};

include/seq/step.hpp

@@ -7,8 +7,10 @@
 
 #include <stdx/ct_string.hpp>
 
+#include <cstdint>
+
 namespace seq {
-enum struct status { NOT_DONE = 0, DONE = 1 };
+enum struct status : std::uint8_t { NOT_DONE, DONE };
 
 using func_ptr = auto (*)() -> status;
 using log_func_ptr = auto (*)() -> void;