natalie_parser 1.0.0

data/include/natalie_parser/node/assignment_node.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class AssignmentNode : public Node {
+public:
+    AssignmentNode(const Token &token, SharedPtr<Node> identifier, SharedPtr<Node> value)
+        : Node { token }
+        , m_identifier { identifier }
+        , m_value { value } {
+        assert(m_identifier);
+        assert(m_value);
+    }
+
+    virtual Type type() const override { return Type::Assignment; }
+
+    const SharedPtr<Node> identifier() const { return m_identifier; }
+    const SharedPtr<Node> value() const { return m_value; }
+
+    virtual void transform(Creator *creator) const override;
+
+protected:
+    SharedPtr<Node> m_identifier {};
+    SharedPtr<Node> m_value {};
+};
+}

data/include/natalie_parser/node/back_ref_node.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class BackRefNode : public Node {
+public:
+    BackRefNode(const Token &token, char ref_type)
+        : Node { token }
+        , m_ref_type { ref_type } { }
+
+    virtual Type type() const override { return Type::BackRef; }
+
+    char ref_type() const { return m_ref_type; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("back_ref");
+        auto type = String(m_ref_type);
+        creator->append_symbol(type);
+    }
+
+protected:
+    char m_ref_type { 0 };
+};
+}

data/include/natalie_parser/node/begin_block_node.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class BeginBlockNode : public Node {
+public:
+    BeginBlockNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::BeginBlock; }
+
+    virtual bool can_accept_a_block() const override { return true; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("preexe");
+    }
+};
+}

data/include/natalie_parser/node/begin_node.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "natalie_parser/node/begin_rescue_node.hpp"
+#include "natalie_parser/node/block_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class BeginNode : public Node {
+public:
+    BeginNode(const Token &token, SharedPtr<BlockNode> body)
+        : Node { token }
+        , m_body { body } {
+        assert(m_body);
+    }
+
+    virtual Type type() const override { return Type::Begin; }
+
+    bool can_be_simple_block() const {
+        return !has_rescue_nodes() && !has_else_body() && !has_ensure_body();
+    }
+
+    void add_rescue_node(SharedPtr<BeginRescueNode> node) { m_rescue_nodes.push(node); }
+    bool has_rescue_nodes() const { return !m_rescue_nodes.is_empty(); }
+
+    bool has_else_body() const { return m_else_body ? true : false; }
+    bool has_ensure_body() const { return m_ensure_body ? true : false; }
+
+    void set_else_body(SharedPtr<BlockNode> else_body) { m_else_body = else_body; }
+    void set_ensure_body(SharedPtr<BlockNode> ensure_body) { m_ensure_body = ensure_body; }
+
+    const SharedPtr<BlockNode> body() const { return m_body; }
+    const SharedPtr<BlockNode> else_body() const { return m_else_body; }
+    const SharedPtr<BlockNode> ensure_body() const { return m_ensure_body; }
+
+    const Vector<SharedPtr<BeginRescueNode>> &rescue_nodes() const { return m_rescue_nodes; }
+
+    virtual void transform(Creator *creator) const override;
+
+protected:
+    SharedPtr<BlockNode> m_body {};
+    SharedPtr<BlockNode> m_else_body {};
+    SharedPtr<BlockNode> m_ensure_body {};
+    Vector<SharedPtr<BeginRescueNode>> m_rescue_nodes {};
+};
+}

data/include/natalie_parser/node/begin_rescue_node.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "natalie_parser/node/block_node.hpp"
+#include "natalie_parser/node/identifier_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class BeginRescueNode : public Node {
+public:
+    BeginRescueNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::BeginRescue; }
+
+    void add_exception_node(SharedPtr<Node> node) {
+        m_exceptions.push(node);
+    }
+
+    void set_exception_name(SharedPtr<IdentifierNode> name) {
+        m_name = name;
+    }
+
+    void set_body(SharedPtr<BlockNode> body) { m_body = body; }
+
+    SharedPtr<Node> name_to_node() const;
+
+    bool has_name() const { return m_name; }
+
+    const SharedPtr<IdentifierNode> name() const { return m_name; }
+    const Vector<SharedPtr<Node>> &exceptions() const { return m_exceptions; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+
+    virtual void transform(Creator *creator) const override;
+
+protected:
+    SharedPtr<IdentifierNode> m_name {};
+    Vector<SharedPtr<Node>> m_exceptions {};
+    SharedPtr<BlockNode> m_body {};
+};
+}

data/include/natalie_parser/node/bignum_node.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class BignumNode : public Node {
+public:
+    BignumNode(const Token &token, SharedPtr<String> number)
+        : Node { token }
+        , m_number { number } { }
+
+    virtual Type type() const override { return Type::Bignum; }
+
+    virtual bool is_numeric() const override { return true; }
+
+    SharedPtr<String> number() const { return m_number; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("lit");
+        creator->append_integer(*m_number);
+    }
+
+    void negate() {
+        assert(m_number->at(0) != '-');
+        m_number->prepend_char('-');
+    }
+
+protected:
+    SharedPtr<String> m_number;
+};
+}

data/include/natalie_parser/node/block_node.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class BlockNode : public Node {
+public:
+    BlockNode(const Token &token)
+        : Node { token } { }
+
+    BlockNode(const Token &token, SharedPtr<Node> single_node)
+        : Node { token } {
+        add_node(single_node);
+    }
+
+    virtual Type type() const override { return Type::Block; }
+
+    const Vector<SharedPtr<Node>> &nodes() const { return m_nodes; }
+
+    void add_node(SharedPtr<Node> node) {
+        m_nodes.push(node);
+    }
+
+    SharedPtr<Node> take_first_node() {
+        return m_nodes.pop_front();
+    }
+
+    bool is_empty() const { return m_nodes.is_empty(); }
+
+    bool has_one_node() const { return m_nodes.size() == 1; }
+    SharedPtr<Node> first() const { return m_nodes.at(0); }
+
+    const Node &without_unnecessary_nesting() const {
+        if (has_one_node())
+            return *first();
+        else
+            return *this;
+    }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("block");
+        for (auto node : m_nodes)
+            creator->append(node);
+    }
+
+protected:
+    Vector<SharedPtr<Node>> m_nodes {};
+};
+}

data/include/natalie_parser/node/block_pass_node.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class BlockPassNode : public Node {
+public:
+    BlockPassNode(const Token &token, SharedPtr<Node> node)
+        : Node { token }
+        , m_node { node } {
+        assert(m_node);
+    }
+
+    virtual Type type() const override { return Type::BlockPass; }
+
+    const SharedPtr<Node> node() const { return m_node; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("block_pass");
+        creator->append(m_node.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_node {};
+};
+}

data/include/natalie_parser/node/break_node.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class BreakNode : public NodeWithArgs {
+public:
+    BreakNode(const Token &token, SharedPtr<Node> arg = {})
+        : NodeWithArgs { token }
+        , m_arg { arg } { }
+
+    virtual Type type() const override { return Type::Break; }
+
+    const SharedPtr<Node> arg() const { return m_arg; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("break");
+        if (m_arg)
+            creator->append(m_arg.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_arg {};
+};
+}

data/include/natalie_parser/node/call_node.hpp

@@ -0,0 +1,85 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class CallNode : public NodeWithArgs {
+public:
+    CallNode(const Token &token, SharedPtr<Node> receiver, SharedPtr<String> message)
+        : NodeWithArgs { token }
+        , m_receiver { receiver }
+        , m_message { message } {
+        assert(m_receiver);
+        assert(m_message);
+    }
+
+    CallNode(const Token &token, CallNode &node)
+        : NodeWithArgs { token }
+        , m_receiver { node.receiver() }
+        , m_message { node.m_message } {
+        for (auto arg : node.m_args) {
+            add_arg(arg);
+        }
+    }
+
+    virtual Type type() const override { return Type::Call; }
+
+    virtual bool is_assignable() const override {
+        return *m_message == "[]" || m_args.is_empty();
+    }
+
+    virtual bool is_callable() const override { return true; }
+
+    virtual bool can_accept_a_block() const override {
+        if (*m_message == "private" || *m_message == "protected" || *m_message == "public")
+            return false;
+        return true;
+    }
+
+    const SharedPtr<Node> receiver() const { return m_receiver; }
+    void set_receiver(SharedPtr<Node> receiver) { m_receiver = receiver; }
+
+    SharedPtr<String> message() const { return m_message; }
+
+    void set_message(SharedPtr<String> message) {
+        assert(message);
+        m_message = message;
+    }
+
+    void set_message(const char *message) {
+        assert(message);
+        m_message = new String(message);
+    }
+
+    virtual void transform(Creator *creator) const override {
+        if (creator->assignment()) {
+            creator->set_type("attrasgn");
+            creator->with_assignment(false, [&]() {
+                creator->append(m_receiver.ref());
+            });
+            auto message = m_message->clone();
+            message.append_char('=');
+            creator->append_symbol(message);
+        } else {
+            creator->set_type("call");
+            creator->append(m_receiver.ref());
+            creator->append_symbol(m_message);
+        }
+        creator->with_assignment(false, [&]() {
+            for (auto arg : args())
+                creator->append(arg);
+        });
+    }
+
+protected:
+    SharedPtr<Node> m_receiver {};
+    SharedPtr<String> m_message {};
+};
+}

data/include/natalie_parser/node/case_in_node.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "natalie_parser/node/block_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class CaseInNode : public Node {
+public:
+    CaseInNode(const Token &token, SharedPtr<Node> pattern, SharedPtr<BlockNode> body)
+        : Node { token }
+        , m_pattern { pattern }
+        , m_body { body } {
+        assert(m_pattern);
+        assert(m_body);
+    }
+
+    virtual Type type() const override { return Type::CaseIn; }
+
+    const SharedPtr<Node> pattern() const { return m_pattern; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("in");
+        creator->append(m_pattern.ref());
+        for (auto node : m_body->nodes())
+            creator->append(node);
+    }
+
+protected:
+    SharedPtr<Node> m_pattern {};
+    SharedPtr<BlockNode> m_body {};
+};
+}

data/include/natalie_parser/node/case_node.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "natalie_parser/node/block_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class CaseNode : public Node {
+public:
+    CaseNode(const Token &token, SharedPtr<Node> subject)
+        : Node { token }
+        , m_subject { subject } {
+        assert(m_subject);
+    }
+
+    virtual Type type() const override { return Type::Case; }
+
+    void add_node(SharedPtr<Node> node) {
+        m_nodes.push(node);
+    }
+
+    void set_else_node(SharedPtr<BlockNode> node) {
+        m_else_node = node;
+    }
+
+    const SharedPtr<Node> subject() const { return m_subject; }
+    Vector<SharedPtr<Node>> &nodes() { return m_nodes; }
+    const SharedPtr<BlockNode> else_node() const { return m_else_node; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("case");
+        creator->append(m_subject.ref());
+        for (auto when_node : m_nodes)
+            creator->append(when_node);
+        if (m_else_node)
+            creator->append(m_else_node->without_unnecessary_nesting());
+        else
+            creator->append_nil();
+    }
+
+protected:
+    SharedPtr<Node> m_subject {};
+    Vector<SharedPtr<Node>> m_nodes {};
+    SharedPtr<BlockNode> m_else_node {};
+};
+}

data/include/natalie_parser/node/case_when_node.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "natalie_parser/node/block_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class CaseWhenNode : public Node {
+public:
+    CaseWhenNode(const Token &token, SharedPtr<Node> condition, SharedPtr<BlockNode> body)
+        : Node { token }
+        , m_condition { condition }
+        , m_body { body } {
+        assert(m_condition);
+        assert(m_body);
+    }
+
+    virtual Type type() const override { return Type::CaseWhen; }
+
+    const SharedPtr<Node> condition() const { return m_condition; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("when");
+        creator->append(m_condition.ref());
+        if (m_body->nodes().is_empty())
+            creator->append_nil();
+        else
+            for (auto node : m_body->nodes())
+                creator->append(node);
+    }
+
+protected:
+    SharedPtr<Node> m_condition {};
+    SharedPtr<BlockNode> m_body {};
+};
+}

data/include/natalie_parser/node/class_node.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "natalie_parser/node/block_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class ClassNode : public Node {
+public:
+    ClassNode(const Token &token, SharedPtr<Node> name, SharedPtr<Node> superclass, SharedPtr<BlockNode> body)
+        : Node { token }
+        , m_name { name }
+        , m_superclass { superclass }
+        , m_body { body } {
+        assert(m_name);
+        assert(m_superclass);
+        assert(m_body);
+    }
+
+    virtual Type type() const override { return Type::Class; }
+
+    const SharedPtr<Node> name() const { return m_name; }
+    const SharedPtr<Node> superclass() const { return m_superclass; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+
+    virtual void transform(Creator *creator) const override;
+
+protected:
+    SharedPtr<Node> m_name {};
+    SharedPtr<Node> m_superclass {};
+    SharedPtr<BlockNode> m_body {};
+};
+}

data/include/natalie_parser/node/colon2_node.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class Colon2Node : public Node {
+public:
+    Colon2Node(const Token &token, SharedPtr<Node> left, SharedPtr<String> name)
+        : Node { token }
+        , m_left { left }
+        , m_name { name } {
+        assert(m_left);
+        assert(m_name);
+    }
+
+    virtual Type type() const override { return Type::Colon2; }
+
+    virtual bool is_assignable() const override { return true; }
+
+    const SharedPtr<Node> left() const { return m_left; }
+    SharedPtr<String> name() const { return m_name; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("colon2");
+        creator->with_assignment(false, [&]() {
+            creator->append(m_left.ref());
+        });
+        creator->append_symbol(m_name);
+        if (creator->assignment())
+            creator->wrap("cdecl");
+    }
+
+protected:
+    SharedPtr<Node> m_left {};
+    SharedPtr<String> m_name {};
+};
+}

data/include/natalie_parser/node/colon3_node.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class Colon3Node : public Node {
+public:
+    Colon3Node(const Token &token, SharedPtr<String> name)
+        : Node { token }
+        , m_name { name } { }
+
+    virtual Type type() const override { return Type::Colon3; }
+
+    virtual bool is_assignable() const override { return true; }
+
+    SharedPtr<String> name() const { return m_name; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("colon3");
+        creator->append_symbol(m_name);
+        if (creator->assignment())
+            creator->wrap("cdecl");
+    }
+
+protected:
+    SharedPtr<String> m_name {};
+};
+}