natalie_parser 1.0.0

data/include/natalie_parser/node/shell_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/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class ShellNode : public Node {
+public:
+    ShellNode(const Token &token, SharedPtr<String> string)
+        : Node { token }
+        , m_string { string } {
+        assert(m_string);
+    }
+
+    virtual Type type() const override { return Type::Shell; }
+
+    SharedPtr<String> string() const { return m_string; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("xstr");
+        creator->append_string(m_string);
+    }
+
+protected:
+    SharedPtr<String> m_string {};
+};
+}

data/include/natalie_parser/node/splat_node.hpp

@@ -0,0 +1,39 @@
+#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 SplatNode : public Node {
+public:
+    SplatNode(const Token &token)
+        : Node { token } { }
+
+    SplatNode(const Token &token, SharedPtr<Node> node)
+        : Node { token }
+        , m_node { node } {
+        assert(m_node);
+    }
+
+    virtual Type type() const override { return Type::Splat; }
+
+    virtual bool is_assignable() const override { return true; }
+
+    const SharedPtr<Node> node() const { return m_node; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("splat");
+        if (m_node)
+            creator->append(m_node.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_node {};
+};
+}

data/include/natalie_parser/node/splat_value_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 SplatValueNode : public Node {
+public:
+    SplatValueNode(const Token &token, SharedPtr<Node> value)
+        : Node { token }
+        , m_value { value } { }
+
+    virtual Type type() const override { return Type::SplatValue; }
+
+    const SharedPtr<Node> value() const { return m_value; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("svalue");
+        creator->append(m_value.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_value {};
+};
+
+}

data/include/natalie_parser/node/stabby_proc_node.hpp

@@ -0,0 +1,29 @@
+#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 StabbyProcNode : public NodeWithArgs {
+public:
+    StabbyProcNode(const Token &token, bool has_args, const Vector<SharedPtr<Node>> &args)
+        : NodeWithArgs { token, args }
+        , m_has_args { has_args } { }
+
+    virtual Type type() const override { return Type::StabbyProc; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("lambda");
+    }
+
+    bool has_args() const { return m_has_args; }
+
+private:
+    bool m_has_args { false };
+};
+}

data/include/natalie_parser/node/string_node.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "natalie_parser/node/interpolated_string_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/symbol_node.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class StringNode : public Node {
+public:
+    StringNode(const Token &token, SharedPtr<String> string)
+        : Node { token }
+        , m_string { string } {
+        assert(m_string);
+    }
+
+    virtual Type type() const override { return Type::String; }
+
+    virtual bool can_be_concatenated_to_a_string() const override { return true; }
+
+    SharedPtr<String> string() const { return m_string; }
+
+    SharedPtr<SymbolNode> to_symbol_node() const {
+        return new SymbolNode { m_token, m_string };
+    }
+
+    SharedPtr<Node> append_string_node(SharedPtr<Node> string2) const;
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("str");
+        creator->append_string(m_string);
+    }
+
+protected:
+    SharedPtr<String> m_string {};
+};
+}

data/include/natalie_parser/node/super_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/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class SuperNode : public NodeWithArgs {
+public:
+    SuperNode(const Token &token)
+        : NodeWithArgs { token } { }
+
+    virtual Type type() const override { return Type::Super; }
+
+    virtual bool is_callable() const override { return true; }
+    virtual bool can_accept_a_block() const override { return true; }
+
+    bool parens() const { return m_parens; }
+    void set_parens(bool parens) { m_parens = parens; }
+
+    bool empty_parens() const { return m_parens && m_args.is_empty(); }
+
+    virtual void transform(Creator *creator) const override {
+        if (empty_parens()) {
+            creator->set_type("super");
+            return;
+        } else if (args().is_empty()) {
+            creator->set_type("zsuper");
+            return;
+        }
+        creator->set_type("super");
+        for (auto arg : args()) {
+            creator->append(arg);
+        }
+    }
+
+protected:
+    bool m_parens { false };
+};
+}

data/include/natalie_parser/node/symbol_key_node.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/symbol_node.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class SymbolKeyNode : public SymbolNode {
+public:
+    using SymbolNode::SymbolNode;
+
+    virtual Type type() const override { return Type::SymbolKey; }
+
+    virtual bool is_symbol_key() const override { return true; }
+};
+}

data/include/natalie_parser/node/symbol_node.hpp

@@ -0,0 +1,30 @@
+#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 SymbolNode : public Node {
+public:
+    SymbolNode(const Token &token, SharedPtr<String> name)
+        : Node { token }
+        , m_name { name } { }
+
+    virtual Type type() const override { return Type::Symbol; }
+
+    SharedPtr<String> name() const { return m_name; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("lit");
+        creator->append_symbol(m_name);
+    }
+
+protected:
+    SharedPtr<String> m_name {};
+};
+}

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

data/include/natalie_parser/node/true_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 TrueNode : public Node {
+public:
+    TrueNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::True; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("true");
+    }
+};
+}

data/include/natalie_parser/node/unary_op_node.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class UnaryOpNode : public Node {
+public:
+    UnaryOpNode(const Token &token, SharedPtr<String> op, SharedPtr<Node> right)
+        : Node { token }
+        , m_op { op }
+        , m_right { right } {
+        assert(m_op);
+        assert(m_right);
+    }
+
+    virtual Type type() const override { return Type::UnaryOp; }
+
+    virtual bool is_callable() const override { return true; }
+    virtual bool can_accept_a_block() const override { return false; }
+
+    const SharedPtr<String> op() const { return m_op; }
+    const SharedPtr<Node> right() const { return m_right; }
+
+    void set_right(SharedPtr<Node> right) { m_right = right; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("call");
+        creator->append(m_right.ref());
+        creator->append_symbol(m_op);
+    }
+
+protected:
+    SharedPtr<String> m_op {};
+    SharedPtr<Node> m_right {};
+};
+}

data/include/natalie_parser/node/undef_node.hpp

@@ -0,0 +1,31 @@
+#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 UndefNode : public NodeWithArgs {
+public:
+    UndefNode(const Token &token)
+        : NodeWithArgs { token } { }
+
+    virtual Type type() const override { return Type::Undef; }
+
+    // NOTE: UndefNode is handled separately from yield, break, etc.,
+    // so for our purposes here, it is not "callable".
+    virtual bool is_callable() const override { return false; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("undef");
+        if (args().is_empty())
+            return;
+        for (auto arg : args())
+            creator->append(arg);
+    }
+};
+}

data/include/natalie_parser/node/until_node.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "natalie_parser/node/block_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/while_node.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class UntilNode : public WhileNode {
+public:
+    UntilNode(const Token &token, SharedPtr<Node> condition, SharedPtr<BlockNode> body, bool pre)
+        : WhileNode { token, condition, body, pre } { }
+
+    virtual Type type() const override { return Type::Until; }
+};
+}

data/include/natalie_parser/node/while_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 WhileNode : public Node {
+public:
+    WhileNode(const Token &token, SharedPtr<Node> condition, SharedPtr<BlockNode> body, bool pre)
+        : Node { token }
+        , m_condition { condition }
+        , m_body { body }
+        , m_pre { pre } {
+        assert(m_condition);
+        assert(m_body);
+    }
+
+    virtual Type type() const override { return Type::While; }
+
+    const SharedPtr<Node> condition() const { return m_condition; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+    bool pre() const { return m_pre; }
+
+    virtual void transform(Creator *creator) const override {
+        if (type() == Node::Type::Until)
+            creator->set_type("until");
+        else
+            creator->set_type("while");
+        creator->append(m_condition.ref());
+        if (m_body->is_empty())
+            creator->append_nil();
+        else
+            creator->append(m_body->without_unnecessary_nesting());
+        if (m_pre)
+            creator->append_true();
+        else
+            creator->append_false();
+    }
+
+protected:
+    SharedPtr<Node> m_condition {};
+    SharedPtr<BlockNode> m_body {};
+    bool m_pre { false };
+};
+}

data/include/natalie_parser/node/yield_node.hpp

@@ -0,0 +1,29 @@
+#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 YieldNode : public NodeWithArgs {
+public:
+    YieldNode(const Token &token)
+        : NodeWithArgs { token } { }
+
+    virtual Type type() const override { return Type::Yield; }
+
+    virtual bool is_callable() const override { return true; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("yield");
+        if (args().is_empty())
+            return;
+        for (auto arg : args())
+            creator->append(arg);
+    }
+};
+}

data/include/natalie_parser/node.hpp

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "natalie_parser/creator.hpp"
+#include "natalie_parser/node/alias_node.hpp"
+#include "natalie_parser/node/arg_node.hpp"
+#include "natalie_parser/node/array_node.hpp"
+#include "natalie_parser/node/array_pattern_node.hpp"
+#include "natalie_parser/node/assignment_node.hpp"
+#include "natalie_parser/node/back_ref_node.hpp"
+#include "natalie_parser/node/begin_block_node.hpp"
+#include "natalie_parser/node/begin_node.hpp"
+#include "natalie_parser/node/begin_rescue_node.hpp"
+#include "natalie_parser/node/bignum_node.hpp"
+#include "natalie_parser/node/block_node.hpp"
+#include "natalie_parser/node/block_pass_node.hpp"
+#include "natalie_parser/node/break_node.hpp"
+#include "natalie_parser/node/call_node.hpp"
+#include "natalie_parser/node/case_in_node.hpp"
+#include "natalie_parser/node/case_node.hpp"
+#include "natalie_parser/node/case_when_node.hpp"
+#include "natalie_parser/node/class_node.hpp"
+#include "natalie_parser/node/colon2_node.hpp"
+#include "natalie_parser/node/colon3_node.hpp"
+#include "natalie_parser/node/constant_node.hpp"
+#include "natalie_parser/node/def_node.hpp"
+#include "natalie_parser/node/defined_node.hpp"
+#include "natalie_parser/node/encoding_node.hpp"
+#include "natalie_parser/node/end_block_node.hpp"
+#include "natalie_parser/node/evaluate_to_string_node.hpp"
+#include "natalie_parser/node/false_node.hpp"
+#include "natalie_parser/node/fixnum_node.hpp"
+#include "natalie_parser/node/float_node.hpp"
+#include "natalie_parser/node/hash_node.hpp"
+#include "natalie_parser/node/hash_pattern_node.hpp"
+#include "natalie_parser/node/identifier_node.hpp"
+#include "natalie_parser/node/if_node.hpp"
+#include "natalie_parser/node/infix_op_node.hpp"
+#include "natalie_parser/node/interpolated_node.hpp"
+#include "natalie_parser/node/interpolated_regexp_node.hpp"
+#include "natalie_parser/node/interpolated_shell_node.hpp"
+#include "natalie_parser/node/interpolated_string_node.hpp"
+#include "natalie_parser/node/interpolated_symbol_key_node.hpp"
+#include "natalie_parser/node/interpolated_symbol_node.hpp"
+#include "natalie_parser/node/iter_node.hpp"
+#include "natalie_parser/node/keyword_arg_node.hpp"
+#include "natalie_parser/node/keyword_splat_node.hpp"
+#include "natalie_parser/node/logical_and_node.hpp"
+#include "natalie_parser/node/logical_or_node.hpp"
+#include "natalie_parser/node/match_node.hpp"
+#include "natalie_parser/node/module_node.hpp"
+#include "natalie_parser/node/multiple_assignment_arg_node.hpp"
+#include "natalie_parser/node/multiple_assignment_node.hpp"
+#include "natalie_parser/node/next_node.hpp"
+#include "natalie_parser/node/nil_node.hpp"
+#include "natalie_parser/node/nil_sexp_node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/not_match_node.hpp"
+#include "natalie_parser/node/not_node.hpp"
+#include "natalie_parser/node/nth_ref_node.hpp"
+#include "natalie_parser/node/op_assign_accessor_node.hpp"
+#include "natalie_parser/node/op_assign_and_node.hpp"
+#include "natalie_parser/node/op_assign_node.hpp"
+#include "natalie_parser/node/op_assign_or_node.hpp"
+#include "natalie_parser/node/pin_node.hpp"
+#include "natalie_parser/node/range_node.hpp"
+#include "natalie_parser/node/redo_node.hpp"
+#include "natalie_parser/node/regexp_node.hpp"
+#include "natalie_parser/node/retry_node.hpp"
+#include "natalie_parser/node/return_node.hpp"
+#include "natalie_parser/node/safe_call_node.hpp"
+#include "natalie_parser/node/sclass_node.hpp"
+#include "natalie_parser/node/self_node.hpp"
+#include "natalie_parser/node/shadow_arg_node.hpp"
+#include "natalie_parser/node/shell_node.hpp"
+#include "natalie_parser/node/splat_node.hpp"
+#include "natalie_parser/node/splat_value_node.hpp"
+#include "natalie_parser/node/stabby_proc_node.hpp"
+#include "natalie_parser/node/string_node.hpp"
+#include "natalie_parser/node/super_node.hpp"
+#include "natalie_parser/node/symbol_key_node.hpp"
+#include "natalie_parser/node/symbol_node.hpp"
+#include "natalie_parser/node/to_array_node.hpp"
+#include "natalie_parser/node/true_node.hpp"
+#include "natalie_parser/node/unary_op_node.hpp"
+#include "natalie_parser/node/undef_node.hpp"
+#include "natalie_parser/node/until_node.hpp"
+#include "natalie_parser/node/while_node.hpp"
+#include "natalie_parser/node/yield_node.hpp"
+#include "natalie_parser/token.hpp"