Merge pull request #201 from OpenBrickProtocolFoundation/fix_clang_tidy_errors

Fix clang tidy errors

Author: Totto16

.github/workflows/lint.yml

@@ -52,7 +52,7 @@ jobs:
           tidy-checks: ''
           step-summary: true
           file-annotations: true
-          ignore: subprojects|build|android|assets|recordings|docs|toolchains|platforms|wrapper|src/libs/core/hash-library|src/lobby/curl_client.*
+          ignore: subprojects|build|android|assets|recordings|docs|toolchains|platforms|wrapper|src/libs/core/hash-library|tests|src/lobby/curl_client.*
 
       - name: Fail CI run if linter checks failed
         if: steps.linter.outputs.checks-failed != 0

src/discord/core.hpp

@@ -110,7 +110,7 @@ struct DiscordInstance {
     std::unique_ptr<discord::Core> m_core;
     std::unique_ptr<discord::User> m_current_user;
 
-    DiscordInstance(discord::Core* core);
+    explicit DiscordInstance(discord::Core* core);
 
 public:
     OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] static helper::expected<DiscordInstance, std::string> initialize();

src/executables/game/application.cpp

@@ -183,7 +183,7 @@ void Application::update() {
             if (scene_change) {
 
                 std::visit(
-                        helper::overloaded{
+                        helper::Overloaded{
                                 [this, index](const scenes::Scene::Pop&) {
                                     m_scene_stack.erase(
                                             m_scene_stack.begin()
@@ -201,10 +201,11 @@ void Application::update() {
                                 },
                                 [this](const scenes::Scene::Switch& scene_switch) {
                                     spdlog::info(
-                                            "switching to scene {}", magic_enum::enum_name(scene_switch.target_scene)
+                                            "switching to scene {}", magic_enum::enum_name(scene_switch.m_target_scene)
+                                    );
+                                    auto scene = scenes::create_scene(
+                                            *this, scene_switch.m_target_scene, scene_switch.m_layout
                                     );
-                                    auto scene =
-                                            scenes::create_scene(*this, scene_switch.target_scene, scene_switch.layout);
 
                                     // only clear, after the construction was successful
                                     m_scene_stack.clear();

src/executables/game/application.hpp

@@ -45,7 +45,8 @@ struct Application final : public EventListener, public ServiceProvider {
 #endif
 
 protected:
-    EventDispatcher m_event_dispatcher;
+    EventDispatcher
+            m_event_dispatcher; //NOLINT(misc-non-private-member-variables-in-classes,cppcoreguidelines-non-private-member-variables-in-classes)
 
 private:
     std::vector<std::unique_ptr<scenes::Scene>> m_scene_stack;

src/executables/utility/main.cpp

@@ -7,50 +7,51 @@
 #include <filesystem>
 #include <iostream>
 
-void print_info(const recorder::RecordingReader& recording_reader) noexcept {
-    //TODO(Totto): Implement, print basic information and final result for each simulation
-    UNUSED(recording_reader);
-    std::cerr << "NOT IMPLEMENTED\n";
-}
+namespace {
+    void print_info(const recorder::RecordingReader& recording_reader) noexcept {
+        //TODO(Totto): Implement, print basic information and final result for each simulation
+        UNUSED(recording_reader);
+        std::cerr << "NOT IMPLEMENTED\n";
+    }
 
-void dump_json(const recorder::RecordingReader& recording_reader, bool pretty_print, bool ensure_ascii) noexcept {
+    void dump_json(const recorder::RecordingReader& recording_reader, bool pretty_print, bool ensure_ascii) noexcept {
 
-    auto result = json::try_convert_to_json<recorder::RecordingReader>(recording_reader);
+        auto result = json::try_convert_to_json<recorder::RecordingReader>(recording_reader);
 
-    if (not result.has_value()) {
-        std::cerr << fmt::format("An error occurred during converting to json: {}\n", result.error());
-        std::exit(1);
-    }
+        if (not result.has_value()) {
+            std::cerr << fmt::format("An error occurred during converting to json: {}\n", result.error());
+            std::exit(1);
+        }
 
 
-    int indent = -1;
-    char indent_char = ' ';
+        int indent = -1;
+        char indent_char = ' ';
 
-    if (pretty_print) {
-        indent = 1;
-        indent_char = '\t';
-    }
+        if (pretty_print) {
+            indent = 1;
+            indent_char = '\t';
+        }
 
-    try {
+        try {
 
-        std::cout << result.value().dump(indent, indent_char, ensure_ascii);
+            std::cout << result.value().dump(indent, indent_char, ensure_ascii);
 
-    } catch (const std::exception& error) {
-        std::cerr << error.what();
-        std::exit(1);
-    }
+        } catch (const std::exception& error) {
+            std::cerr << error.what();
+            std::exit(1);
+        }
 
-    if (pretty_print) {
-        std::cout << "\n";
+        if (pretty_print) {
+            std::cout << "\n";
+        }
     }
-}
 
+} // namespace
 
 int main(int argc, char** argv) noexcept {
 
     try {
 
-
         auto arguments_result = CommandLineArguments::from_args(argc, argv);
 
         if (not arguments_result.has_value()) {
@@ -80,7 +81,7 @@ int main(int argc, char** argv) noexcept {
         const auto recording_reader = std::move(parsed.value());
 
         std::visit(
-                helper::overloaded{ [&recording_reader](const Dump& dump) {
+                helper::Overloaded{ [&recording_reader](const Dump& dump) {
                                        dump_json(recording_reader, dump.pretty_print, dump.ensure_ascii);
                                    },
                                     [&recording_reader](const Info& /* info */) { print_info(recording_reader); } },

src/game/bag.cpp

@@ -3,7 +3,9 @@
 Bag::Bag(Random& random) : m_tetromino_sequence{} {
     // initialize array with invalid tetromino type
     for (helper::TetrominoType& type : m_tetromino_sequence) {
-        type = static_cast<helper::TetrominoType>(static_cast<int>(helper::TetrominoType::LastType) + 1);
+        type = static_cast<helper::TetrominoType>( //NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
+                static_cast<int>(helper::TetrominoType::LastType) + 1
+        );
     }
 
     // fill in the sequence with random order

src/game/grid.cpp

@@ -6,7 +6,7 @@
 Grid::Grid(const ui::Layout& layout, bool is_top_level)
     : ui::Widget{ layout, ui::WidgetType::Component, is_top_level } {
 
-    const u32 total_x_tiles = grid::preview_extends.x * 2 + 2 + grid::width_in_tiles;
+    const u32 total_x_tiles = (grid::preview_extends.x * 2) + 2 + grid::width_in_tiles;
     constexpr u32 total_y_tiles = grid::height_in_tiles;
 
     const u32 tile_size_x = layout.get_rect().width() / total_x_tiles;
@@ -86,7 +86,7 @@ void Grid::draw_background(const ServiceProvider& service_provider, GridRect gri
 
     for (u32 column = 0; column <= grid_rect.width(); ++column) {
         const auto start = top_left + shapes::UPoint{ column * m_tile_size, 0 };
-        const auto end = shapes::UPoint{ start.x, start.y + grid_rect.height() * m_tile_size };
+        const auto end = shapes::UPoint{ start.x, start.y + (grid_rect.height() * m_tile_size) };
         service_provider.renderer().draw_line(start, end, grid_color);
         service_provider.renderer().draw_line(start - shapes::UPoint{ 1, 0 }, end - shapes::UPoint{ 1, 0 }, grid_color);
     }
@@ -100,8 +100,8 @@ void Grid::draw_background(const ServiceProvider& service_provider, GridRect gri
 
     const auto outline_top_left = top_left - shapes::UPoint{ 2, 2 };
     const auto outline_bottom_right = shapes::UPoint{
-        top_left.x + grid_rect.width() * m_tile_size + 1,
-        top_left.y + grid_rect.height() * m_tile_size + 1,
+        top_left.x + (grid_rect.width() * m_tile_size) + 1,
+        top_left.y + (grid_rect.height() * m_tile_size) + 1,
     };
 
     const auto outline_rect = shapes::URect{

src/game/tetrion.cpp

@@ -24,7 +24,7 @@ Tetrion::Tetrion(
     : ui::Widget{ layout , ui::WidgetType::Component ,is_top_level},
         SimulatedTetrion{tetrion_index,random_seed,starting_level, service_provider,std::move(recording_writer)},
       m_main_layout{
-                utils::size_t_identity<2>(),
+                utils::SizeIdentity<2>(),
                 0,
                 ui::Direction::Vertical,
                 { 0.85 },

src/graphics/rect.hpp

@@ -17,9 +17,9 @@ namespace shapes {
         constexpr AbstractRect(Point top_left, Point bottom_right) // NOLINT(bugprone-easily-swappable-parameters)
             : top_left{ top_left },
               bottom_right{ bottom_right } { }
-        constexpr AbstractRect(T x, T y, T width, T height)
-            : top_left{ x, y },
-              bottom_right{ x + width - 1, y + height - 1 } { }
+        constexpr AbstractRect(T x_pos, T y_pos, T width, T height)
+            : top_left{ x_pos, y_pos },
+              bottom_right{ x_pos + width - 1, y_pos + height - 1 } { }
 
         [[nodiscard]] constexpr T width() const {
             return static_cast<T>(bottom_right.x - top_left.x + 1);

src/graphics/renderer.cpp

@@ -91,35 +91,36 @@ void Renderer::draw_self_computed_circle_impl(const shapes::IPoint& center, i32
 
     const i32 radius = diameter / 2;
 
-    i32 x = radius - 1;
-    i32 y = 0;
-    i32 tx = 1;
-    i32 ty = 1;
-    i32 error = tx - diameter;
+    i32 x_pos = radius - 1;
+    i32 y_pos = 0;
+    i32 tx_pos = 1;
+    i32 ty_pos = 1;
+    i32 error = tx_pos - diameter;
 
-    while (x >= y) {
+    while (x_pos >= y_pos) {
         //  Each of the following renders an octant of the circle
         SDL_RenderDrawPoint(
-                m_renderer, center_x + x, center_y - y // NOLINT(clang-analyzer-core.UndefinedBinaryOperatorResult)
+                m_renderer, center_x + x_pos, // NOLINT(clang-analyzer-core.UndefinedBinaryOperatorResult)
+                center_y - y_pos
         );
-        SDL_RenderDrawPoint(m_renderer, center_x + x, center_y + y);
-        SDL_RenderDrawPoint(m_renderer, center_x - x, center_y - y);
-        SDL_RenderDrawPoint(m_renderer, center_x - x, center_y + y);
-        SDL_RenderDrawPoint(m_renderer, center_x + y, center_y - x);
-        SDL_RenderDrawPoint(m_renderer, center_x + y, center_y + x);
-        SDL_RenderDrawPoint(m_renderer, center_x - y, center_y - x);
-        SDL_RenderDrawPoint(m_renderer, center_x - y, center_y + x);
+        SDL_RenderDrawPoint(m_renderer, center_x + x_pos, center_y + y_pos);
+        SDL_RenderDrawPoint(m_renderer, center_x - x_pos, center_y - y_pos);
+        SDL_RenderDrawPoint(m_renderer, center_x - x_pos, center_y + y_pos);
+        SDL_RenderDrawPoint(m_renderer, center_x + y_pos, center_y - x_pos);
+        SDL_RenderDrawPoint(m_renderer, center_x + y_pos, center_y + x_pos);
+        SDL_RenderDrawPoint(m_renderer, center_x - y_pos, center_y - x_pos);
+        SDL_RenderDrawPoint(m_renderer, center_x - y_pos, center_y + x_pos);
 
         if (error <= 0) {
-            ++y;
-            error += ty;
-            ty += 2;
+            ++y_pos;
+            error += ty_pos;
+            ty_pos += 2;
         }
 
         if (error > 0) {
-            --x;
-            tx += 2;
-            error += (tx - diameter);
+            --x_pos;
+            tx_pos += 2;
+            error += (tx_pos - diameter);
         }
     }
 }