chore: enhancing code with cppcheck suggestions

Author: SuperFola

include/Ark/Compiler/Lowerer/ASTLowerer.hpp

@@ -180,13 +180,13 @@ namespace Ark::internal
          */
         void compileExpression(Node& x, Page p, bool is_result_unused, bool is_terminal);
 
-        void compileSymbol(Node& x, Page p, bool is_result_unused);
+        void compileSymbol(const Node& x, Page p, bool is_result_unused);
         void compileListInstruction(Node& x, Page p, bool is_result_unused);
         void compileIf(Node& x, Page p, bool is_result_unused, bool is_terminal);
         void compileFunction(Node& x, Page p, bool is_result_unused);
         void compileLetMutSet(Keyword n, Node& x, Page p);
         void compileWhile(Node& x, Page p);
-        void compilePluginImport(Node& x, Page p);
+        void compilePluginImport(const Node& x, Page p);
         void pushFunctionCallArguments(Node& call, Page p, bool is_tail_call);
         void handleCalls(Node& x, Page p, bool is_result_unused, bool is_terminal);
 

src/arkreactor/Builtins/Dict.cpp

@@ -17,6 +17,7 @@ namespace Ark::internal::Builtins::Dict
      * =end
      * @author https://github.com/SuperFola
      */
+    // cppcheck-suppress constParameterReference
     Value dict(std::vector<Value>& n, VM* vm [[maybe_unused]])
     {
         if (n.size() % 2 != 0)

src/arkreactor/Builtins/IO.cpp

@@ -78,6 +78,7 @@ namespace Ark::internal::Builtins::IO
         return Value(line);
     }
 
+    // cppcheck-suppress constParameterReference
     Value writeFile(std::vector<Value>& n, VM* vm [[maybe_unused]])
     {
         if (types::check(n, ValueType::String, ValueType::Any))
@@ -102,6 +103,7 @@ namespace Ark::internal::Builtins::IO
         return nil;
     }
 
+    // cppcheck-suppress constParameterReference
     Value appendToFile(std::vector<Value>& n, VM* vm [[maybe_unused]])
     {
         if (types::check(n, ValueType::String, ValueType::Any))

src/arkreactor/Compiler/Lowerer/ASTLowerer.cpp

@@ -241,7 +241,7 @@ namespace Ark::internal
                 x);
     }
 
-    void ASTLowerer::compileSymbol(Node& x, const Page p, const bool is_result_unused)
+    void ASTLowerer::compileSymbol(const Node& x, const Page p, const bool is_result_unused)
     {
         const std::string& name = x.string();
 
@@ -504,7 +504,7 @@ namespace Ark::internal
         m_locals_locator.deleteScope();
     }
 
-    void ASTLowerer::compilePluginImport(Node& x, const Page p)
+    void ASTLowerer::compilePluginImport(const Node& x, const Page p)
     {
         std::string path;
         const Node package_node = x.constList()[1];

src/arkreactor/Compiler/NameResolution/NameResolutionPass.cpp

@@ -144,17 +144,20 @@ namespace Ark::internal
                 // if we had specific symbols to import, check that those exist
                 if (!namespace_.symbols.empty())
                 {
-                    for (const auto& sym : namespace_.symbols)
-                    {
-                        if (!scope->get(sym, true).has_value())
-                            throw CodeError(
-                                fmt::format("ImportError: Can not import symbol {} from {}, as it isn't in the package", sym, namespace_.name),
-                                CodeErrorContext(
-                                    namespace_.ast->filename(),
-                                    namespace_.ast->line(),
-                                    namespace_.ast->col(),
-                                    "import"));
-                    }
+                    const auto it = std::ranges::find_if(
+                        namespace_.symbols,
+                        [&scope](const std::string& sym) -> bool {
+                            return !scope->get(sym, true).has_value();
+                        });
+
+                    if (it != namespace_.symbols.end())
+                        throw CodeError(
+                            fmt::format("ImportError: Can not import symbol {} from {}, as it isn't in the package", *it, namespace_.name),
+                            CodeErrorContext(
+                                namespace_.ast->filename(),
+                                namespace_.ast->line(),
+                                namespace_.ast->col(),
+                                "import"));
                 }
 
                 m_scope_resolver.saveNamespaceAndRemove();
@@ -266,7 +269,7 @@ namespace Ark::internal
                             // update the declared variable name to use the fully qualified name
                             // this will prevent name conflicts, and handle scope resolution
                             std::string old_name = child.string();
-                            std::string fqn = updateSymbolWithFullyQualifiedName(child);
+                            updateSymbolWithFullyQualifiedName(child);
                             // FIXME: addDefinedSymbol(fqn, true); ?
                             addDefinedSymbol(old_name, true);
                         }

src/arkreactor/VM/Future.cpp

@@ -4,6 +4,7 @@
 
 namespace Ark::internal
 {
+    // cppcheck-suppress constParameterReference
     Future::Future(ExecutionContext* context, VM* vm, std::vector<Value>& args)
     {
         m_value = std::async(

src/arkreactor/VM/VM.cpp

@@ -353,19 +353,21 @@ namespace Ark
 
         if (m_execution_contexts.size() > 1)
         {
-            for (std::size_t i = 0; i < m_execution_contexts.size(); ++i)
+            const auto it = std::ranges::find_if(
+                m_execution_contexts,
+                [](const std::unique_ptr<ExecutionContext>& context) -> bool {
+                    return !context->primary && context->isFree();
+                });
+
+            if (it != m_execution_contexts.end())
             {
-                if (!m_execution_contexts[i]->primary && m_execution_contexts[i]->isFree())
-                {
-                    ctx = m_execution_contexts[i].get();
-                    ctx->setActive(true);
-                    // reset the context before using it
-                    ctx->sp = 0;
-                    ctx->saved_scope.reset();
-                    ctx->stacked_closure_scopes.clear();
-                    ctx->locals.clear();
-                    break;
-                }
+                ctx = it->get();
+                ctx->setActive(true);
+                // reset the context before using it
+                ctx->sp = 0;
+                ctx->saved_scope.reset();
+                ctx->stacked_closure_scopes.clear();
+                ctx->locals.clear();
             }
         }