fix: addressing cppcheck warnings

SuperFola · SuperFola · commit fa81b1d3da0b · 2024-07-12T19:18:22.000+02:00
diff --git a/include/Ark/Compiler/AST/Parser.hpp b/include/Ark/Compiler/AST/Parser.hpp
@@ -174,13 +174,13 @@ namespace Ark::internal
 
         std::optional<Node> field()
         {
-            std::string symbol;
-            if (!name(&symbol))
+            std::string sym;
+            if (!name(&sym))
                 return std::nullopt;
 
             std::optional<Node> leaf { Node(NodeType::Field) };
             setNodePosAndFilename(leaf.value());
-            leaf->push_back(Node(NodeType::Symbol, symbol));
+            leaf->push_back(Node(NodeType::Symbol, sym));
 
             while (true)
             {
diff --git a/include/Ark/Compiler/AST/Predicates.hpp b/include/Ark/Compiler/AST/Predicates.hpp
@@ -114,7 +114,7 @@ namespace Ark::internal
         explicit IsChar(const char c) :
             CharPred("'" + std::string(1, c) + "'"), m_k(c)
         {}
-        explicit IsChar(const utf8_char_t c) :
+        explicit IsChar(const utf8_char_t& c) :
             CharPred(std::string(c.c_str())), m_k(c.codepoint())
         {}
         bool operator()(const utf8_char_t::codepoint_t c) const override
diff --git a/include/Ark/Compiler/AST/utf8_char.hpp b/include/Ark/Compiler/AST/utf8_char.hpp
@@ -25,7 +25,7 @@ namespace Ark::internal
         // https://github.com/sheredom/utf8.h/blob/4e4d828174c35e4564c31a9e35580c299c69a063/utf8.h#L1178
         static std::pair<std::string::iterator, utf8_char_t> at(std::string::iterator it, const std::string::iterator end)
         {
-            codepoint_t codepoint;
+            codepoint_t cp;
             length_t length;
             repr_t repr = {};
 
@@ -34,7 +34,7 @@ namespace Ark::internal
                 if (it + 3 == end || it + 2 == end || it + 1 == end)
                     return std::make_pair(end, utf8_char_t {});
 
-                codepoint = (static_cast<codepoint_t>(0x07 & *it) << 18) |
+                cp = (static_cast<codepoint_t>(0x07 & *it) << 18) |
                     (static_cast<codepoint_t>(0x3f & *(it + 1)) << 12) |
                     (static_cast<codepoint_t>(0x3f & *(it + 2)) << 6) |
                     static_cast<codepoint_t>(0x3f & *(it + 3));
@@ -45,7 +45,7 @@ namespace Ark::internal
                 if (it + 2 == end || it + 1 == end)
                     return std::make_pair(end, utf8_char_t {});
 
-                codepoint = (static_cast<codepoint_t>(0x0f & *it) << 12) |
+                cp = (static_cast<codepoint_t>(0x0f & *it) << 12) |
                     (static_cast<codepoint_t>(0x3f & *(it + 1)) << 6) |
                     static_cast<codepoint_t>(0x3f & *(it + 2));
                 length = 3;
@@ -55,21 +55,21 @@ namespace Ark::internal
                 if (it + 1 == end)
                     return std::make_pair(end, utf8_char_t {});
 
-                codepoint = (static_cast<codepoint_t>(0x1f & *it) << 6) |
+                cp = (static_cast<codepoint_t>(0x1f & *it) << 6) |
                     static_cast<codepoint_t>(0x3f & *(it + 1));
                 length = 2;
             }
             else  // 1 byte utf8 codepoint otherwise
             {
-                codepoint = static_cast<unsigned char>(*it);
+                cp = static_cast<unsigned char>(*it);
                 length = 1;
             }
 
             for (length_t i = 0; i < length; ++i)
                 repr[i] = static_cast<unsigned char>(*(it + static_cast<int>(i)));
 
             return std::make_pair(it + static_cast<long>(length),
-                                  utf8_char_t(codepoint, length, repr));
+                                  utf8_char_t(cp, length, repr));
         }
 
         [[nodiscard]] bool isPrintable() const
diff --git a/include/Ark/TypeChecker.hpp b/include/Ark/TypeChecker.hpp
@@ -2,7 +2,7 @@
  * @file TypeChecker.hpp
  * @author Alexandre Plateau (lexplt.dev@gmail.com)
  * @brief
- * @version 0.4
+ * @version 1.0
  * @date 2022-01-16
  *
  * @copyright Copyright (c) 2022-2024
@@ -66,11 +66,11 @@ namespace Ark::types
         std::vector<ValueType> types;
         bool variadic;
 
-        Typedef(const std::string_view type_name, const ValueType type, const bool is_variadic = false) :
+        Typedef(const std::string_view& type_name, const ValueType type, const bool is_variadic = false) :
             name(type_name), types { type }, variadic(is_variadic)
         {}
 
-        Typedef(const std::string_view type_name, const std::vector<ValueType>& type_list, const bool is_variadic = false) :
+        Typedef(const std::string_view& type_name, const std::vector<ValueType>& type_list, const bool is_variadic = false) :
             name(type_name), types(type_list), variadic(is_variadic)
         {}
     };
@@ -91,7 +91,7 @@ namespace Ark::types
      * @param contracts types contracts the function can follow
      * @param args provided argument list
      */
-    ARK_API void generateError [[noreturn]] (std::string_view funcname, const std::vector<Contract>& contracts, const std::vector<Value>& args);
+    ARK_API void generateError [[noreturn]] (const std::string_view& funcname, const std::vector<Contract>& contracts, const std::vector<Value>& args);
 }
 
 #endif
diff --git a/src/arkreactor/Compiler/AST/BaseParser.cpp b/src/arkreactor/Compiler/AST/BaseParser.cpp
@@ -314,13 +314,9 @@ namespace Ark::internal
 
     bool BaseParser::sequence(const std::string& s)
     {
-        for (const char i : s)
-        {
-            if (!accept(IsChar(i)))
-                return false;
-        }
-
-        return true;
+        return std::ranges::all_of(s, [this](const char c) {
+            return accept(IsChar(c));
+        });
     }
 
     bool BaseParser::packageName(std::string* s)
@@ -354,11 +350,8 @@ namespace Ark::internal
         if (s)
             *s = buffer;
 
-        for (const auto& word : words)
-        {
-            if (word == buffer)
-                return true;
-        }
-        return false;
+        return std::ranges::any_of(words, [&buffer](const std::string& word) {
+            return word == buffer;
+        });
     }
 }
diff --git a/src/arkreactor/Compiler/Compiler.cpp b/src/arkreactor/Compiler/Compiler.cpp
@@ -141,8 +141,9 @@ namespace Ark
         {
             // push the string, null terminated
             std::string s = sym.string();
-            for (const char i : s)
-                m_bytecode.push_back(static_cast<uint8_t>(i));
+            std::ranges::transform(s, std::back_inserter(m_bytecode), [](const char i) {
+                return static_cast<uint8_t>(i);
+            });
             m_bytecode.push_back(0_u8);
         }
 
@@ -161,15 +162,17 @@ namespace Ark
                 m_bytecode.push_back(NUMBER_TYPE);
                 const auto n = std::get<double>(val.value);
                 std::string t = std::to_string(n);
-                for (const char i : t)
-                    m_bytecode.push_back(static_cast<uint8_t>(i));
+                std::ranges::transform(t, std::back_inserter(m_bytecode), [](const char i) {
+                    return static_cast<uint8_t>(i);
+                });
             }
             else if (val.type == ValTableElemType::String)
             {
                 m_bytecode.push_back(STRING_TYPE);
                 auto t = std::get<std::string>(val.value);
-                for (const char i : t)
-                    m_bytecode.push_back(static_cast<uint8_t>(i));
+                std::ranges::transform(t, std::back_inserter(m_bytecode), [](const char i) {
+                    return static_cast<uint8_t>(i);
+                });
             }
             else if (val.type == ValTableElemType::PageAddr)
             {
diff --git a/src/arkreactor/Compiler/ImportSolver.cpp b/src/arkreactor/Compiler/ImportSolver.cpp
@@ -148,8 +148,9 @@ namespace Ark::internal
             module_node.push_back(Node(Keyword::Import));
 
             auto package_node = Node(NodeType::List);
-            for (const std::string& stem : import.package)
-                package_node.push_back(Node(NodeType::String, stem));
+            std::ranges::transform(import.package, std::back_inserter(package_node.list()), [](const std::string& stem) {
+                return Node(NodeType::String, stem);
+            });
             module_node.push_back(package_node);
             // empty symbols list
             module_node.push_back(Node(NodeType::List));
diff --git a/src/arkreactor/TypeChecker.cpp b/src/arkreactor/TypeChecker.cpp
@@ -77,7 +77,7 @@ namespace Ark::types
         }
     }
 
-    [[noreturn]] void generateError(std::string_view funcname, const std::vector<Contract>& contracts, const std::vector<Value>& args)
+    [[noreturn]] void generateError(const std::string_view& funcname, const std::vector<Contract>& contracts, const std::vector<Value>& args)
     {
         std::cout << "Function " << termcolor::blue << funcname << termcolor::reset << " expected ";
 
diff --git a/src/arkreactor/VM/Future.cpp b/src/arkreactor/VM/Future.cpp
@@ -5,12 +5,10 @@
 namespace Ark::internal
 {
     Future::Future(ExecutionContext* context, VM* vm, std::vector<Value>& args) :
-        m_context(context), m_vm(vm)
-    {
-        m_value = std::async(std::launch::async, [vm, context, args]() mutable {
+        m_context(context), m_vm(vm), m_value(std::async(std::launch::async, [vm, context, args]() mutable {
             return vm->resolve(context, args);
-        });
-    }
+        }))
+    {}
 
     Value Future::resolve()
     {
diff --git a/src/arkreactor/VM/State.cpp b/src/arkreactor/VM/State.cpp
@@ -125,8 +125,9 @@ namespace Ark
     void State::setArgs(const std::vector<std::string>& args) noexcept
     {
         Value val(ValueType::List);
-        for (const std::string& arg : args)
-            val.push_back(Value(arg));
+        std::ranges::transform(args, std::back_inserter(val.list()), [](const std::string& arg) {
+            return Value(arg);
+        });
         m_binded["sys:args"] = val;
 
         m_binded["sys:platform"] = Value(ARK_PLATFORM_NAME);
diff --git a/src/arkreactor/VM/VM.cpp b/src/arkreactor/VM/VM.cpp
@@ -67,8 +67,6 @@ namespace Ark
 
     Value& VM::operator[](const std::string& name) noexcept
     {
-        ExecutionContext& context = *m_execution_contexts.front();
-
         // find id of object
         const auto it = std::ranges::find(m_state.m_symbols, name);
         if (it == m_state.m_symbols.end())
@@ -80,11 +78,14 @@ namespace Ark
         const auto dist = std::distance(m_state.m_symbols.begin(), it);
         if (std::cmp_less(dist, std::numeric_limits<uint16_t>::max()))
         {
+            ExecutionContext& context = *m_execution_contexts.front();
+
             const auto id = static_cast<uint16_t>(dist);
             Value* var = findNearestVariable(id, context);
             if (var != nullptr)
                 return *var;
         }
+
         m_no_value = Builtins::nil;
         return m_no_value;
     }
@@ -558,8 +559,7 @@ namespace Ark
                                     { { types::Contract { { types::Typedef("dst", ValueType::List), types::Typedef("src", ValueType::List) } } } },
                                     { *list, *next });
 
-                            for (auto& val : next->list())
-                                obj.push_back(val);
+                            std::ranges::copy(next->list(), std::back_inserter(obj.list()));
                         }
                         push(std::move(obj), context);
                         break;
@@ -608,8 +608,7 @@ namespace Ark
                                     { { types::Contract { { types::Typedef("dst", ValueType::List), types::Typedef("src", ValueType::List) } } } },
                                     { *list, *next });
 
-                            for (auto& it : next->list())
-                                list->push_back(it);
+                            std::ranges::copy(next->list(), std::back_inserter(list->list()));
                         }
 
                         break;
diff --git a/src/arkscript/main.cpp b/src/arkscript/main.cpp
@@ -137,15 +137,17 @@ int main(int argc, char** argv)
         // if arkscript lib paths were provided by the CLI, bypass the automatic lookup
         if (!libdir.empty())
         {
-            for (const auto& path : Utils::splitString(libdir, ';'))
-                lib_paths.emplace_back(path);
+            std::ranges::transform(Utils::splitString(libdir, ';'), std::back_inserter(lib_paths), [](const std::string& path) {
+                return std::filesystem::path(path);
+            });
         }
         else
         {
             if (const char* arkpath = std::getenv("ARKSCRIPT_PATH"))
             {
-                for (const auto& path : Utils::splitString(arkpath, ';'))
-                    lib_paths.emplace_back(path);
+                std::ranges::transform(Utils::splitString(arkpath, ';'), std::back_inserter(lib_paths), [](const std::string& path) {
+                    return std::filesystem::path(path);
+                });
             }
             else if (Utils::fileExists("./lib"))
                 lib_paths.emplace_back("lib");

Original file line number	Diff line number	Diff line change
`@@ -174,13 +174,13 @@ namespace Ark::internal`
`174`	`174`
`175`	`175`	`std::optional<Node> field()`
`176`	`176`	`{`
`177`		`- std::string symbol;`
`178`		`- if (!name(&symbol))`
	`177`	`+ std::string sym;`
	`178`	`+ if (!name(&sym))`
`179`	`179`	`return std::nullopt;`
`180`	`180`
`181`	`181`	`std::optional<Node> leaf { Node(NodeType::Field) };`
`182`	`182`	`setNodePosAndFilename(leaf.value());`
`183`		`- leaf->push_back(Node(NodeType::Symbol, symbol));`
	`183`	`+ leaf->push_back(Node(NodeType::Symbol, sym));`
`184`	`184`
`185`	`185`	`while (true)`
`186`	`186`	`{`
Original file line number	Diff line number	Diff line change
`@@ -141,8 +141,9 @@ namespace Ark`
`141`	`141`	`{`
`142`	`142`	`// push the string, null terminated`
`143`	`143`	`std::string s = sym.string();`
`144`		`- for (const char i : s)`
`145`		`- m_bytecode.push_back(static_cast<uint8_t>(i));`
	`144`	`+ std::ranges::transform(s, std::back_inserter(m_bytecode), [](const char i) {`
	`145`	`+ return static_cast<uint8_t>(i);`
	`146`	`+ });`
`146`	`147`	`m_bytecode.push_back(0_u8);`
`147`	`148`	`}`
`148`	`149`
`@@ -161,15 +162,17 @@ namespace Ark`
`161`	`162`	`m_bytecode.push_back(NUMBER_TYPE);`
`162`	`163`	`const auto n = std::get<double>(val.value);`
`163`	`164`	`std::string t = std::to_string(n);`
`164`		`- for (const char i : t)`
`165`		`- m_bytecode.push_back(static_cast<uint8_t>(i));`
	`165`	`+ std::ranges::transform(t, std::back_inserter(m_bytecode), [](const char i) {`
	`166`	`+ return static_cast<uint8_t>(i);`
	`167`	`+ });`
`166`	`168`	`}`
`167`	`169`	`else if (val.type == ValTableElemType::String)`
`168`	`170`	`{`
`169`	`171`	`m_bytecode.push_back(STRING_TYPE);`
`170`	`172`	`auto t = std::get<std::string>(val.value);`
`171`		`- for (const char i : t)`
`172`		`- m_bytecode.push_back(static_cast<uint8_t>(i));`
	`173`	`+ std::ranges::transform(t, std::back_inserter(m_bytecode), [](const char i) {`
	`174`	`+ return static_cast<uint8_t>(i);`
	`175`	`+ });`
`173`	`176`	`}`
`174`	`177`	`else if (val.type == ValTableElemType::PageAddr)`
`175`	`178`	`{`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ namespace Ark::types`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`80`		`- [[noreturn]] void generateError(std::string_view funcname, const std::vector<Contract>& contracts, const std::vector<Value>& args)`
	`80`	`+ [[noreturn]] void generateError(const std::string_view& funcname, const std::vector<Contract>& contracts, const std::vector<Value>& args)`
`81`	`81`	`{`
`82`	`82`	`std::cout << "Function " << termcolor::blue << funcname << termcolor::reset << " expected ";`
`83`	`83`