natalie_parser 1.0.0

data/include/natalie_parser/node/node_with_args.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "natalie_parser/creator.hpp"
+#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 NodeWithArgs : public Node {
+public:
+    NodeWithArgs(const Token &token)
+        : Node { token } { }
+
+    NodeWithArgs(const Token &token, const Vector<SharedPtr<Node>> &args)
+        : Node { token } {
+        for (auto arg : args)
+            add_arg(arg);
+    }
+
+    NodeWithArgs(const NodeWithArgs &other)
+        : NodeWithArgs { other.token() } {
+        for (auto arg : other.args())
+            add_arg(arg);
+    }
+
+    void add_arg(SharedPtr<Node> arg) {
+        // TODO: error if BlockPass already added (must be last)
+        m_args.push(arg);
+    }
+
+    bool has_block_pass() const override {
+        return m_args.size() > 0 && m_args.last()->type() == Node::Type::BlockPass;
+    }
+
+    Vector<SharedPtr<Node>> &args() { return m_args; }
+    const Vector<SharedPtr<Node>> &args() const { return m_args; }
+
+    void append_method_or_block_args(Creator *creator) const;
+
+protected:
+    Vector<SharedPtr<Node>> m_args {};
+};
+}

data/include/natalie_parser/node/not_match_node.hpp

@@ -0,0 +1,35 @@
+#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 NotMatchNode : public Node {
+public:
+    NotMatchNode(const Token &token, SharedPtr<Node> expression)
+        : Node { token }
+        , m_expression { expression } {
+        assert(m_expression);
+    }
+
+    virtual Type type() const override { return Type::NotMatch; }
+
+    const SharedPtr<Node> expression() const { return m_expression; }
+
+    void set_expression(SharedPtr<Node> expression) { m_expression = expression; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("not");
+        creator->append(m_expression.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_expression {};
+};
+}

data/include/natalie_parser/node/not_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/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class NotNode : public Node {
+public:
+    NotNode(const Token &token, SharedPtr<Node> expression)
+        : Node { token }
+        , m_expression { expression } {
+        assert(m_expression);
+    }
+
+    virtual Type type() const override { return Type::Not; }
+
+    const SharedPtr<Node> expression() const { return m_expression; }
+
+    void set_expression(SharedPtr<Node> expression) { m_expression = expression; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("call");
+        creator->append(m_expression.ref());
+        auto message = String("!");
+        creator->append_symbol(message);
+    }
+
+protected:
+    SharedPtr<Node> m_expression {};
+};
+}

data/include/natalie_parser/node/nth_ref_node.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class NthRefNode : public Node {
+public:
+    NthRefNode(const Token &token, long long num)
+        : Node { token }
+        , m_num { num } { }
+
+    virtual Type type() const override { return Type::NthRef; }
+
+    long long num() const { return m_num; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("nth_ref");
+        creator->append_integer(m_num);
+    }
+
+protected:
+    long long m_num { 0 };
+};
+}

data/include/natalie_parser/node/op_assign_accessor_node.hpp

@@ -0,0 +1,74 @@
+#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 OpAssignAccessorNode : public NodeWithArgs {
+public:
+    OpAssignAccessorNode(const Token &token, SharedPtr<String> op, SharedPtr<Node> receiver, SharedPtr<String> message, SharedPtr<Node> value, Vector<SharedPtr<Node>> &args)
+        : NodeWithArgs { token }
+        , m_op { op }
+        , m_receiver { receiver }
+        , m_message { message }
+        , m_value { value } {
+        assert(m_op);
+        assert(m_receiver);
+        assert(m_message);
+        assert(m_value);
+        for (auto arg : args)
+            add_arg(arg);
+    }
+
+    virtual Type type() const override { return Type::OpAssignAccessor; }
+
+    const SharedPtr<String> op() const { return m_op; }
+    const SharedPtr<Node> receiver() const { return m_receiver; }
+    const SharedPtr<String> message() const { return m_message; }
+    const SharedPtr<Node> value() const { return m_value; }
+
+    bool safe() const { return m_safe; }
+    void set_safe(bool safe) { m_safe = safe; }
+
+    virtual void transform(Creator *creator) const override {
+        if (*m_message == "[]=") {
+            creator->set_type("op_asgn1");
+            creator->append(m_receiver.ref());
+            if (m_args.is_empty()) {
+                creator->append_nil();
+            } else {
+                creator->append_sexp([&](Creator *c) {
+                    c->set_type("arglist");
+                    for (auto arg : m_args)
+                        c->append(arg);
+                });
+            }
+            creator->append_symbol(m_op);
+            creator->append(m_value.ref());
+            return;
+        }
+        assert(args().is_empty());
+        if (m_safe)
+            creator->set_type("safe_op_asgn2");
+        else
+            creator->set_type("op_asgn2");
+        creator->append(m_receiver.ref());
+        creator->append_symbol(m_message);
+        creator->append_symbol(m_op);
+        creator->append(m_value.ref());
+    }
+
+protected:
+    SharedPtr<String> m_op {};
+    SharedPtr<Node> m_receiver {};
+    SharedPtr<String> m_message {};
+    SharedPtr<Node> m_value {};
+    bool m_safe { false };
+};
+}

data/include/natalie_parser/node/op_assign_and_node.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "natalie_parser/node/assignment_node.hpp"
+#include "natalie_parser/node/identifier_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/op_assign_node.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class OpAssignAndNode : public OpAssignNode {
+public:
+    OpAssignAndNode(const Token &token, SharedPtr<Node> name, SharedPtr<Node> value)
+        : OpAssignNode { token, name, value } { }
+
+    virtual Type type() const override { return Type::OpAssignAnd; }
+
+    virtual void transform(Creator *creator) const override {
+        // s(:op_asgn_and, s(:lvar, :x), s(:lasgn, :x, s(:lit, 1)))
+        creator->set_type("op_asgn_and");
+        creator->append(m_name.ref());
+        auto assignment = AssignmentNode {
+            token(),
+            m_name.static_cast_as<Node>(),
+            m_value
+        };
+        creator->append(assignment);
+    }
+};
+}

data/include/natalie_parser/node/op_assign_node.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "natalie_parser/node/call_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/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class OpAssignNode : public Node {
+public:
+    OpAssignNode(const Token &token, SharedPtr<Node> name, SharedPtr<Node> value)
+        : Node { token }
+        , m_name { name }
+        , m_value { value } {
+        assert(m_name);
+        assert(m_value);
+    }
+
+    OpAssignNode(const Token &token, SharedPtr<String> op, SharedPtr<Node> name, SharedPtr<Node> value)
+        : Node { token }
+        , m_op { op }
+        , m_name { name }
+        , m_value { value } {
+        assert(m_op);
+        assert(m_name);
+        assert(m_value);
+    }
+
+    virtual Type type() const override { return Type::OpAssign; }
+
+    const SharedPtr<String> op() const { return m_op; }
+    const SharedPtr<Node> name() const { return m_name; }
+    const SharedPtr<Node> value() const { return m_value; }
+
+    virtual void transform(Creator *creator) const override;
+
+protected:
+    SharedPtr<String> m_op {};
+    SharedPtr<Node> m_name {};
+    SharedPtr<Node> m_value {};
+};
+}

data/include/natalie_parser/node/op_assign_or_node.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "natalie_parser/node/assignment_node.hpp"
+#include "natalie_parser/node/identifier_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/op_assign_node.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class OpAssignOrNode : public OpAssignNode {
+public:
+    OpAssignOrNode(const Token &token, SharedPtr<Node> name, SharedPtr<Node> value)
+        : OpAssignNode { token, name, value } { }
+
+    virtual Type type() const override { return Type::OpAssignOr; }
+
+    virtual void transform(Creator *creator) const override {
+        // s(:op_asgn_or, s(:lvar, :x), s(:lasgn, :x, s(:lit, 1)))
+        creator->set_type("op_asgn_or");
+        creator->append(m_name.ref());
+        auto assignment = AssignmentNode {
+            token(),
+            m_name.static_cast_as<Node>(),
+            m_value
+        };
+        creator->append(assignment);
+    }
+};
+}

data/include/natalie_parser/node/pin_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 PinNode : public Node {
+public:
+    PinNode(const Token &token, SharedPtr<Node> identifier)
+        : Node { token }
+        , m_identifier { identifier } {
+        assert(m_identifier);
+    }
+
+    virtual Type type() const override { return Type::Pin; }
+
+    const SharedPtr<Node> identifier() const { return m_identifier; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("pin");
+        creator->append(m_identifier.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_identifier {};
+};
+}

data/include/natalie_parser/node/range_node.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "natalie_parser/node/fixnum_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 RangeNode : public Node {
+public:
+    RangeNode(const Token &token, SharedPtr<Node> first, SharedPtr<Node> last, bool exclude_end)
+        : Node { token }
+        , m_first { first }
+        , m_last { last }
+        , m_exclude_end { exclude_end } {
+        assert(m_first);
+        assert(m_last);
+    }
+
+    virtual Type type() const override { return Type::Range; }
+
+    const SharedPtr<Node> first() const { return m_first; }
+    const SharedPtr<Node> last() const { return m_last; }
+    bool exclude_end() const { return m_exclude_end; }
+
+    virtual void transform(Creator *creator) const override {
+        if (m_first->type() == Node::Type::Fixnum && m_last->type() == Node::Type::Fixnum) {
+            creator->set_type("lit");
+            auto first_num = m_first.static_cast_as<FixnumNode>()->number();
+            auto last_num = m_last.static_cast_as<FixnumNode>()->number();
+            creator->append_range(first_num, last_num, m_exclude_end);
+        } else {
+            if (m_exclude_end)
+                creator->set_type("dot3");
+            else
+                creator->set_type("dot2");
+            creator->append(m_first.ref());
+            creator->append(m_last.ref());
+        }
+    }
+
+protected:
+    SharedPtr<Node> m_first {};
+    SharedPtr<Node> m_last {};
+    bool m_exclude_end { false };
+};
+}

data/include/natalie_parser/node/redo_node.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class RedoNode : public Node {
+public:
+    RedoNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::Redo; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("redo");
+    }
+};
+}

data/include/natalie_parser/node/regexp_node.hpp

@@ -0,0 +1,36 @@
+#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 RegexpNode : public Node {
+public:
+    RegexpNode(const Token &token, SharedPtr<String> pattern)
+        : Node { token }
+        , m_pattern { pattern } {
+        assert(m_pattern);
+    }
+
+    virtual Type type() const override { return Type::Regexp; }
+
+    SharedPtr<String> pattern() const { return m_pattern; }
+
+    int options() const { return m_options; }
+    void set_options(int options) { m_options = options; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("lit");
+        creator->append_regexp(m_pattern, m_options);
+    }
+
+protected:
+    SharedPtr<String> m_pattern {};
+    int m_options { 0 };
+};
+}

data/include/natalie_parser/node/retry_node.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class RetryNode : public Node {
+public:
+    RetryNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::Retry; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("retry");
+    }
+};
+}

data/include/natalie_parser/node/return_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 ReturnNode : public Node {
+public:
+    ReturnNode(const Token &token, SharedPtr<Node> value)
+        : Node { token }
+        , m_value { value } {
+        assert(m_value);
+    }
+
+    virtual Type type() const override { return Type::Return; }
+
+    const SharedPtr<Node> value() const { return m_value; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("return");
+        if (m_value->type() != Node::Type::Nil)
+            creator->append(m_value.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_value {};
+};
+}

data/include/natalie_parser/node/safe_call_node.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "natalie_parser/node/call_node.hpp"
+#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 SafeCallNode : public CallNode {
+public:
+    SafeCallNode(const Token &token, SharedPtr<Node> receiver, SharedPtr<String> message)
+        : CallNode { token, receiver, message } { }
+
+    SafeCallNode(const Token &token, CallNode &node)
+        : CallNode { token, node } { }
+
+    virtual Type type() const override { return Type::SafeCall; }
+
+    virtual void transform(Creator *creator) const override {
+        CallNode::transform(creator);
+        if (creator->assignment())
+            creator->set_type("safe_attrasgn");
+        else
+            creator->set_type("safe_call");
+    }
+};
+}

data/include/natalie_parser/node/sclass_node.hpp

@@ -0,0 +1,37 @@
+#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 SclassNode : public Node {
+public:
+    SclassNode(const Token &token, SharedPtr<Node> klass, SharedPtr<BlockNode> body)
+        : Node { token }
+        , m_klass { klass }
+        , m_body { body } { }
+
+    virtual Type type() const override { return Type::Sclass; }
+
+    const SharedPtr<Node> klass() const { return m_klass; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("sclass");
+        creator->append(m_klass.ref());
+        for (auto node : m_body->nodes())
+            creator->append(node);
+    }
+
+protected:
+    SharedPtr<Node> m_klass {};
+    SharedPtr<BlockNode> m_body {};
+};
+}

data/include/natalie_parser/node/self_node.hpp

@@ -0,0 +1,23 @@
+#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 SelfNode : public Node {
+public:
+    SelfNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::Self; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("self");
+    }
+};
+}

data/include/natalie_parser/node/shadow_arg_node.hpp

@@ -0,0 +1,40 @@
+#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 ShadowArgNode : public Node {
+public:
+    ShadowArgNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::ShadowArg; }
+
+    const Vector<SharedPtr<String>> &names() const { return m_names; }
+
+    void add_name(SharedPtr<String> name) {
+        m_names.push(name);
+    }
+
+    void add_to_locals(TM::Hashmap<TM::String> &locals) {
+        for (auto name : m_names)
+            locals.set(name->c_str());
+    }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("shadow");
+        for (auto name : m_names)
+            creator->append_symbol(name);
+    }
+
+protected:
+    Vector<SharedPtr<String>> m_names {};
+};
+}