generic: clang-tidy warning fixes

Author: rizsotto

source/citnames/config.json

@@ -37,7 +37,7 @@ namespace cs {
     rust::Result<cs::semantic::SemanticPtrs> semantic::ToolExtendingWrapper::compilations(const report::Command &command) const {
         return ToolGcc().compilations(command)
                 .map<cs::semantic::SemanticPtrs>([this](auto semantics) {
-                    for (auto semantic : semantics) {
+                    for (auto& semantic : semantics) {
                         semantic->extend_flags(compilers_to_recognize_.additional_flags);
                     }
                     return semantics;

source/citnames/source/semantic/ToolExtendingWrapper.cc

@@ -21,78 +21,76 @@
 
 #include <cstddef>
 
-namespace el {
-    namespace array {
+namespace el::array {
 
-        /**
-         * Return a pointer to the last element of a nullptr terminated array.
-         *
-         * @param it the input array to count,
-         * @return the pointer which points the nullptr.
-         */
-        template <typename T>
-        constexpr T* end(T* it) noexcept
-        {
-            if (it == nullptr)
-                return nullptr;
+    /**
+     * Return a pointer to the last element of a nullptr terminated array.
+     *
+     * @param it the input array to count,
+     * @return the pointer which points the nullptr.
+     */
+    template <typename T>
+    constexpr T* end(T* it) noexcept
+    {
+        if (it == nullptr)
+            return nullptr;
 
-            while (*it != 0)
-                ++it;
-            return it;
-        }
+        while (*it != 0)
+            ++it;
+        return it;
+    }
 
-        /**
-         * Return the size of a nullptr terminated array.
-         *
-         * @param begin the input array to count,
-         * @return the size of the array.
-         */
-        template <typename T>
-        constexpr size_t length(T* const begin) noexcept
-        {
-            return end(begin) - begin;
-        }
+    /**
+     * Return the size of a nullptr terminated array.
+     *
+     * @param begin the input array to count,
+     * @return the size of the array.
+     */
+    template <typename T>
+    constexpr size_t length(T* const begin) noexcept
+    {
+        return end(begin) - begin;
+    }
 
-        /**
-         * Re-implementation of std::copy to avoid `memmove` symbol.
-         *
-         * @tparam I input type
-         * @tparam O output type
-         * @param src_begin
-         * @param src_end
-         * @param dst_begin
-         * @param dst_end
-         * @return output iterator to the last copied element.
-         */
-        template <typename I, typename O>
-        constexpr O* copy(I* const src_begin, I* const src_end,
-            O* const dst_begin, O* const dst_end) noexcept
-        {
-            auto src_it = src_begin;
-            auto dst_it = dst_begin;
-            for (; src_it != src_end && dst_it != dst_end;)
-                *dst_it++ = *src_it++;
+    /**
+     * Re-implementation of std::copy to avoid `memmove` symbol.
+     *
+     * @tparam I input type
+     * @tparam O output type
+     * @param src_begin
+     * @param src_end
+     * @param dst_begin
+     * @param dst_end
+     * @return output iterator to the last copied element.
+     */
+    template <typename I, typename O>
+    constexpr O* copy(I* const src_begin, I* const src_end,
+        O* const dst_begin, O* const dst_end) noexcept
+    {
+        auto src_it = src_begin;
+        auto dst_it = dst_begin;
+        for (; src_it != src_end && dst_it != dst_end;)
+            *dst_it++ = *src_it++;
 
-            return (src_it == src_end) ? dst_it : nullptr;
-        }
+        return (src_it == src_end) ? dst_it : nullptr;
+    }
 
-        /**
-         * Check if two nullptr terminated array is equal till the limit.
-         *
-         * @tparam T
-         * @param lhs
-         * @param rhs
-         * @param length
-         * @return true if the two array is equal till the limit.
-         */
-        template <typename T>
-        constexpr bool equal_n(T* const lhs, T* const rhs, const size_t length) noexcept
-        {
-            for (size_t idx = 0; idx < length; ++idx) {
-                if (lhs[idx] != rhs[idx])
-                    return false;
-            }
-            return true;
+    /**
+     * Check if two nullptr terminated array is equal till the limit.
+     *
+     * @tparam T
+     * @param lhs
+     * @param rhs
+     * @param length
+     * @return true if the two array is equal till the limit.
+     */
+    template <typename T>
+    constexpr bool equal_n(T* const lhs, T* const rhs, const size_t length) noexcept
+    {
+        for (size_t idx = 0; idx < length; ++idx) {
+            if (lhs[idx] != rhs[idx])
+                return false;
         }
+        return true;
     }
 }

source/intercept-library/library/source/Array.h

@@ -49,15 +49,15 @@ namespace {
 
 #define CHECK_SESSION(SESSION_)                           \
     do {                                                  \
-        if (!el::session::is_valid(SESSION_)) {          \
+        if (!el::session::is_valid(SESSION_)) {           \
             LOGGER.warning("session is not initialized"); \
             return failure(EIO);                          \
         }                                                 \
     } while (false)
 
 #define CHECK_POINTER(PTR_)                        \
     do {                                           \
-        if (nullptr == PTR_) {                     \
+        if (nullptr == (PTR_)) {                   \
             LOGGER.debug("null pointer received"); \
             return failure(EFAULT);                \
         }                                          \

source/intercept-library/library/source/Executor.cc

@@ -19,37 +19,33 @@
 
 #pragma once
 
-namespace el {
+namespace el::log {
 
-    namespace log {
+    enum Level {
+        SILENT = 0,
+        VERBOSE = 1
+    };
 
-        enum Level {
-            SILENT = 0,
-            VERBOSE = 1
-        };
+    // Not MT safe
+    void set(Level);
 
-        // Not MT safe
-        void set(Level);
+    class Logger {
+    public:
+        constexpr explicit Logger(const char *name) noexcept;
 
-        class Logger {
-        public:
-            constexpr explicit Logger(const char *name) noexcept;
+        ~Logger() noexcept = default;
 
-            ~Logger() noexcept = default;
+        void debug(char const *message) const noexcept;
+        void debug(char const *message, char const *variable) const noexcept;
 
-            void debug(char const* message) const noexcept;
-            void debug(char const* message, char const* variable) const noexcept;
+        void warning(char const *message) const noexcept;
 
-            void warning(char const* message) const noexcept;
+    private:
+        const char *name_;
+    };
 
-        private:
-            const char* name_;
-        };
-
-        inline constexpr
-        Logger::Logger(const char* name) noexcept
-                : name_(name)
-        {
-        }
-    }
+    inline constexpr
+    Logger::Logger(const char *name) noexcept
+            : name_(name)
+    { }
 }

source/intercept-library/library/source/Logger.h

@@ -56,8 +56,8 @@ namespace el {
 
         virtual size_t confstr(int name, char* buf, size_t len) const noexcept;
 
-        virtual const char** environment() const noexcept;
+        [[nodiscard]] virtual const char** environment() const noexcept;
 
-        virtual int error_code() const noexcept;
+        [[nodiscard]] virtual int error_code() const noexcept;
     };
 }

source/intercept-library/library/source/Resolver.h

@@ -23,33 +23,30 @@
 #include "Environment.h"
 #include "libexec/Environment.h"
 
-namespace el {
-
-    namespace session {
-
-        void from(Session& session, const char** environment) noexcept
-        {
-            if (nullptr == environment)
-                return;
-
-            session.reporter = env::get_env_value(environment, env::KEY_REPORTER);
-            session.destination = env::get_env_value(environment, env::KEY_DESTINATION);
-            session.verbose = env::get_env_value(environment, env::KEY_VERBOSE) != nullptr;
-        }
-
-        void persist(Session& session, char* begin, char* end) noexcept
-        {
-            if (!is_valid(session))
-                return;
-
-            Buffer buffer(begin, end);
-            session.reporter = buffer.store(session.reporter);
-            session.destination = buffer.store(session.destination);
-        }
-
-        bool is_valid(Session const& session) noexcept
-        {
-            return (session.reporter != nullptr && session.destination != nullptr);
-        }
+namespace el::session {
+
+    void from(Session &session, const char **environment) noexcept
+    {
+        if (nullptr == environment)
+            return;
+
+        session.reporter = env::get_env_value(environment, env::KEY_REPORTER);
+        session.destination = env::get_env_value(environment, env::KEY_DESTINATION);
+        session.verbose = env::get_env_value(environment, env::KEY_VERBOSE) != nullptr;
+    }
+
+    void persist(Session &session, char *begin, char *end) noexcept
+    {
+        if (!is_valid(session))
+            return;
+
+        Buffer buffer(begin, end);
+        session.reporter = buffer.store(session.reporter);
+        session.destination = buffer.store(session.destination);
+    }
+
+    bool is_valid(Session const &session) noexcept
+    {
+        return (session.reporter != nullptr && session.destination != nullptr);
     }
 }