improve moves

Author: Prevter

src/parser.cpp

@@ -1,6 +1,7 @@
 #include <rift/parser.hpp>
 
 #include <stack>
+#include <iterator>
 
 #include <rift/nodes/accessor.hpp>
 #include <rift/nodes/assign.hpp>
@@ -123,15 +124,31 @@ namespace rift {
                     auto resNode = std::move(res.unwrap());
                     if (resNode->type() == Node::Type::Value) {
                         auto* valNode = static_cast<ValueNode*>(resNode.get());
-                        // if it's a string, add the value to previous segment node (if any)
-                        if (valNode->value().type() == Value::Type::String || valNode->value().type() == Value::Type::Integer || valNode->value().type() == Value::Type::Boolean) {
+                        auto const& val = valNode->value();
+                        if (
+                            val.type() == Value::Type::String ||
+                            val.type() == Value::Type::Integer ||
+                            val.type() == Value::Type::Boolean
+                        ) {
+                            auto appendValue = [](std::string& dest, Value const& value) {
+                                if (value.type() == Value::Type::String) {
+                                    dest.append(value.getString());
+                                } else {
+                                    fmt::format_to(std::back_inserter(dest), "{}", value);
+                                }
+                            };
+
                             if (!nodes.empty() && nodes.back()->type() == Node::Type::Segment) {
-                                // append to the last segment node
                                 auto* segNode = static_cast<SegmentNode*>(nodes.back().get());
-                                segNode->value() += valNode->value().toString();
+                                appendValue(segNode->value(), val);
                             } else {
-                                // create a new segment node
-                                nodes.push_back(std::make_unique<SegmentNode>(valNode->value().toString(), valNode->fromIndex(), valNode->toIndex()));
+                                std::string segmentValue;
+                                if (val.type() == Value::Type::String) {
+                                    segmentValue = val.getString();
+                                } else {
+                                    segmentValue = fmt::format("{}", val);
+                                }
+                                nodes.push_back(std::make_unique<SegmentNode>(std::move(segmentValue), valNode->fromIndex(), valNode->toIndex()));
                             }
 
                             // consume the right brace

src/rift.cpp

@@ -8,15 +8,15 @@ namespace rift {
         Parser parser(Lexer(source, directMode), directMode);
         auto result = parser.parse();
         if (result.isErr()) {
-            return geode::Err(result.unwrapErr());
+            return geode::Err(std::move(result).unwrapErr());
         }
-        return geode::Ok(std::make_unique<Script>(std::move(result.unwrap())));
+        return geode::Ok(std::make_unique<Script>(std::move(result).unwrap()));
     }
 
     FormatResult format(std::string_view source, Object const& variables) noexcept {
         auto compileResult = compile(source, false);
         if (compileResult.isErr()) {
-            return geode::Err(compileResult.unwrapErr());
+            return geode::Err(std::move(compileResult).unwrapErr());
         }
 
         auto runResult = compileResult.unwrap()->run(variables);
@@ -29,13 +29,13 @@ namespace rift {
             ));
         }
 
-        return geode::Ok(runResult.unwrap());
+        return geode::Ok(std::move(runResult).unwrap());
     }
 
     EvaluateResult evaluate(std::string_view source, Object const& variables) noexcept {
         auto compileResult = compile(source, true);
         if (compileResult.isErr()) {
-            return geode::Err(compileResult.unwrapErr());
+            return geode::Err(std::move(compileResult).unwrapErr());
         }
 
         auto evalResult = compileResult.unwrap()->eval(variables);
@@ -48,7 +48,7 @@ namespace rift {
             ));
         }
 
-        return geode::Ok(evalResult.unwrap());
+        return geode::Ok(std::move(evalResult).unwrap());
     }
 
 }

src/script.cpp

@@ -6,7 +6,7 @@ namespace rift {
     RunResult Script::run(Object const &variables) noexcept {
         auto result = eval(variables);
         if (result.isErr()) {
-            return geode::Err(std::move(result.unwrapErr()));
+            return geode::Err(std::move(result).unwrapErr());
         }
         return geode::Ok(result.unwrap().toString());
     }
@@ -15,9 +15,9 @@ namespace rift {
         Visitor visitor(variables, m_variables);
         auto result = visitor.visit(*m_root);
         if (result.isErr()) {
-            return geode::Err(std::move(result.unwrapErr()));
+            return geode::Err(std::move(result).unwrapErr());
         }
-        return geode::Ok(std::move(result.unwrap()));
+        return geode::Ok(std::move(result).unwrap());
     }
 
 }

src/value.cpp

@@ -3,6 +3,7 @@
 
 #include <fmt/format.h>
 #include <algorithm>
+#include <iterator>
 
 namespace rift {
 #ifdef RIFT_INCLUDE_MATJSON
@@ -172,7 +173,21 @@ namespace rift {
 
         // if either value is a string, concatenate them
         if (isString() || other.isString()) {
-            return geode::Ok(Value(toString() + other.toString()));
+            std::string result;
+            auto const stringSize = [](Value const& value) {
+                return value.isString() ? value.getString().size() : size_t{0};
+            };
+            result.reserve(stringSize(*this) + stringSize(other));
+            auto const appendValueText = [](std::string& dest, Value const& value) {
+                if (value.isString()) {
+                    dest.append(value.getString());
+                } else {
+                    fmt::format_to(std::back_inserter(dest), "{}", value);
+                }
+            };
+            appendValueText(result, *this);
+            appendValueText(result, other);
+            return geode::Ok(Value(std::move(result)));
         }
 
         // if either value is a float, convert both to floats and add