unfold RootNode for constants

Author: Prevter

include/rift/nodes/segment.hpp

@@ -24,6 +24,10 @@ namespace rift {
             return m_value;
         }
 
+        [[nodiscard]] std::string& value() noexcept {
+            return m_value;
+        }
+
     private:
         std::string m_value;
     };

include/rift/nodes/unary.hpp

@@ -23,6 +23,10 @@ namespace rift {
             return *m_value;
         }
 
+        [[nodiscard]] std::unique_ptr<Node> const& valuePtr() const noexcept {
+            return m_value;
+        }
+
     private:
         std::unique_ptr<Node> m_value;
         TokenType m_op;

include/rift/script.hpp

@@ -31,6 +31,10 @@ namespace rift {
         [[nodiscard]] Object& getVariables() noexcept { return m_variables; }
         [[nodiscard]] Object const& getVariables() const noexcept { return m_variables; }
 
+        [[nodiscard]] std::unique_ptr<Node> const& getRoot() const noexcept {
+            return m_root;
+        }
+
     private:
         std::unique_ptr<Node> m_root;
         Object m_variables;

src/parser.cpp

@@ -103,7 +103,14 @@ namespace rift {
         while (m_currentToken) {
             switch (m_currentToken.type) {
                 case TokenType::SEGMENT: {
-                    nodes.push_back(std::make_unique<SegmentNode>(m_currentToken));
+                    // check if previous token is a segment
+                    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() += m_currentToken.value;
+                    } else {
+                        nodes.push_back(std::make_unique<SegmentNode>(m_currentToken));
+                    }
                     UNWRAP_ADVANCE()
                 } break;
                 case TokenType::LEFT_BRACE: {
@@ -112,7 +119,26 @@ namespace rift {
                     if (res.isErr()) {
                         return res;
                     }
-                    nodes.push_back(std::move(res.unwrap()));
+                    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) {
+                            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();
+                            } else {
+                                // create a new segment node
+                                nodes.push_back(std::make_unique<SegmentNode>(valNode->value().toString(), valNode->fromIndex(), valNode->toIndex()));
+                            }
+
+                            // consume the right brace
+                            CONSUME_TOKEN(TokenType::RIGHT_BRACE)
+                            break;
+                        }
+                    }
+                    nodes.push_back(std::move(resNode));
                     CONSUME_TOKEN(TokenType::RIGHT_BRACE);
                 } break;
                 default: {

test/main.cpp

@@ -55,7 +55,7 @@ void RIFT_TEST(std::string_view code, std::string_view expected, rift::Object co
     RIFT_EVAL(code, expected, vars, false);
 }
 
-std::string myCustomFunc(std::string name) {
+std::string myCustomFunc(std::string const& name) {
     return fmt::format("Hello, {}!", name);
 }