refactor: to use std::ranges where applicable (#542)

Author: hrzlgnm

.clang-tidy

@@ -2,7 +2,7 @@
 # Enable ALL the things! Except not really useful ones, needs to be a string
 Checks: >
   *,
-  -*-use-ranges,
+  -misc-no-recursion,
   -*c++98-compat-*,
   -altera-*,
   -bugprone-easily-swappable-parameters,

source/builtin/builtin.cpp

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: MIT-0
 
 #include <algorithm>
-#include <cctype>
 #include <functional>
 #include <iterator>
+#include <ranges>
 #include <string>
 #include <utility>
 #include <vector>
@@ -144,7 +144,7 @@ const builtin rest {
         if (maybe_string_or_array->is(array)) {
             if (const auto& arr = maybe_string_or_array->as<array_object>()->value; arr.size() > 1) {
                 array_object::value_type rest;
-                std::copy(arr.cbegin() + 1, arr.cend(), std::back_inserter(rest));
+                std::ranges::copy(arr | std::ranges::views::drop(1), std::back_inserter(rest));
                 return allocate<array_object>(std::move(rest));
             }
             return null();

source/code/code.cpp

@@ -3,8 +3,10 @@
 
 #include <array>
 #include <cstdint>
+#include <iterator>
 #include <optional>
 #include <ostream>
+#include <ranges>
 #include <stdexcept>
 #include <string>
 #include <utility>
@@ -251,7 +253,7 @@ auto flatten(const std::vector<std::vector<T>>& arrs) -> std::vector<T>
 {
     std::vector<T> result;
     for (const auto& arr : arrs) {
-        std::copy(arr.cbegin(), arr.cend(), std::back_inserter(result));
+        std::ranges::copy(arr, std::back_inserter(result));
     }
     return result;
 }

source/compiler/compiler.cpp

@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <iterator>
 #include <optional>
+#include <ranges>
 #include <stdexcept>
 #include <string>
 #include <utility>
@@ -76,7 +77,7 @@ auto compiler::add_instructions(const instructions& ins) -> std::size_t
 {
     auto& scope = m_scopes[m_scope_index];
     const auto pos = scope.instrs.size();
-    std::copy(ins.cbegin(), ins.cend(), std::back_inserter(scope.instrs));
+    std::ranges::copy(ins, std::back_inserter(scope.instrs));
     return pos;
 }
 
@@ -118,9 +119,9 @@ auto compiler::replace_last_pop_with_return() -> void
 auto compiler::replace_instruction(const std::size_t pos, const instructions& instr) -> void
 {
     // cppcheck-suppress variableScope
-    auto& scope = m_scopes[m_scope_index];
+    auto& target_instrs = m_scopes[m_scope_index].instrs;
     for (auto idx = 0UL; const auto& inst : instr) {
-        scope.instrs[pos + idx] = inst;
+        target_instrs[pos + idx] = inst;
         idx++;
     }
 }
@@ -549,7 +550,7 @@ auto flatten(const std::vector<std::vector<T>>& arrs) -> std::vector<T>
 {
     std::vector<T> result;
     for (const auto& arr : arrs) {
-        std::copy(arr.cbegin(), arr.cend(), std::back_inserter(result));
+        std::ranges::copy(arr, std::back_inserter(result));
     }
     return result;
 }

source/compiler/compiler.hpp

@@ -45,6 +45,7 @@ struct compiler final : visitor
 
     [[nodiscard]] auto add_constant(const object* obj) -> std::size_t;
     [[nodiscard]] auto add_instructions(const instructions& ins) -> std::size_t;
+
     auto emit(opcodes opcode, const operands& operands = {}) -> std::size_t;
 
     auto emit(const opcodes opcode, const std::size_t operand) -> std::size_t

source/object/object.cpp

@@ -7,6 +7,7 @@
 #include <ios>
 #include <iterator>
 #include <ostream>
+#include <ranges>
 #include <sstream>
 #include <string>
 #include <utility>
@@ -106,7 +107,7 @@ auto multiply_sequence_helper(const T* source, const integer_object::value_type
 {
     typename T::value_type target;
     for (integer_object::value_type i = 0; i < count; i++) {
-        std::copy(source->value.cbegin(), source->value.cend(), std::back_inserter(target));
+        std::ranges::copy(source->value, std::back_inserter(target));
     }
     return allocate<T>(std::move(target));
 }
@@ -779,11 +780,8 @@ auto array_object::operator==(const object& other) const -> const object*
         if (other_value.size() != value.size()) {
             return fals();
         }
-        const auto eq = std::equal(value.cbegin(),
-                                   value.cend(),
-                                   other_value.cbegin(),
-                                   other_value.cend(),
-                                   [](const object* a, const object* b) { return object_eq(*a, *b); });
+        const auto eq = std::ranges::equal(
+            value, other_value, [](const object* a, const object* b) -> bool { return object_eq(*a, *b); });
         return native_bool_to_object(eq);
     }
     return fals();
@@ -802,7 +800,7 @@ auto array_object::operator+(const object& other) const -> const object*
     if (other.is(array)) {
         value_type concat = value;
         const auto& other_value = other.as<array_object>()->value;
-        std::copy(other_value.cbegin(), other_value.cend(), std::back_inserter(concat));
+        std::ranges::copy(other_value, std::back_inserter(concat));
         return allocate<array_object>(std::move(concat));
     }
     return nullptr;
@@ -812,9 +810,9 @@ auto operator<<(std::ostream& strm, const hashable::key_type& t) -> std::ostream
 {
     std::visit(
         overloaded {
-            [&](const int64_t val) { strm << val; },
-            [&](const std::string& val) { strm << '"' << val << '"'; },
-            [&](const bool val) { strm << std::boolalpha << val; },
+            [&](const int64_t val) -> void { strm << val; },
+            [&](const std::string& val) -> void { strm << '"' << val << '"'; },
+            [&](const bool val) -> void { strm << std::boolalpha << val; },
         },
         t);
     return strm;
@@ -843,14 +841,13 @@ auto hash_object::operator==(const object& other) const -> const object*
         if (other_value.size() != value.size()) {
             return fals();
         }
-        const auto eq = std::all_of(value.cbegin(),
-                                    value.cend(),
-                                    [&other_value](const auto& pair)
-                                    {
-                                        const auto& [key, value] = pair;
-                                        auto it = other_value.find(key);
-                                        return it != other_value.cend() && object_eq(*(it->second), *value);
-                                    });
+        const auto eq = std::ranges::all_of(value,
+                                            [&other_value](const auto& pair) -> auto
+                                            {
+                                                const auto& [key, value] = pair;
+                                                auto it = other_value.find(key);
+                                                return it != other_value.cend() && object_eq(*(it->second), *value);
+                                            });
         return native_bool_to_object(eq);
     }
     return object::operator==(other);

source/vm/vm.cpp

@@ -648,14 +648,14 @@ auto require_eq(const std::variant<T...>& expected, const object*& actual, const
     using enum object::object_type;
     std::visit(
         overloaded {
-            [&](const int64_t exp) { require_is(exp, actual, input); },
-            [&](const double exp) { require_is(exp, actual, input); },
-            [&](const bool exp) { require_is(exp, actual, input); },
-            [&](const null_type& /*null*/) { REQUIRE(actual->is_null()); },
-            [&](const std::string& exp) { require_is(exp, actual, input); },
-            [&](const ::error& exp) { require_is(exp, actual, input); },
-            [&](const std::vector<int>& exp) { require_array_object(exp, actual, input); },
-            [&](const ::hash& exp) { require_hash_object(exp, actual, input); },
+            [&](const int64_t exp) -> auto { require_is(exp, actual, input); },
+            [&](const double exp) -> auto { require_is(exp, actual, input); },
+            [&](const bool exp) -> auto { require_is(exp, actual, input); },
+            [&](const null_type& /*null*/) -> auto { REQUIRE(actual->is_null()); },
+            [&](const std::string& exp) -> auto { require_is(exp, actual, input); },
+            [&](const ::error& exp) -> auto { require_is(exp, actual, input); },
+            [&](const std::vector<int>& exp) -> auto { require_array_object(exp, actual, input); },
+            [&](const ::hash& exp) -> auto { require_hash_object(exp, actual, input); },
         },
         expected);
 }