natalie_parser 1.0.0

data/include/natalie_parser/node/interpolated_string_node.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "natalie_parser/node/interpolated_node.hpp"
+#include "natalie_parser/node/interpolated_symbol_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 InterpolatedStringNode : public InterpolatedNode {
+public:
+    InterpolatedStringNode(const Token &token)
+        : InterpolatedNode { token } { }
+
+    virtual Type type() const override { return Type::InterpolatedString; }
+
+    virtual bool can_be_concatenated_to_a_string() const override { return true; }
+
+    SharedPtr<InterpolatedSymbolNode> to_symbol_node() const {
+        return new InterpolatedSymbolNode { *this };
+    }
+
+    SharedPtr<Node> append_string_node(SharedPtr<Node> string2) const;
+
+    virtual void transform(Creator *creator) const override;
+};
+}

data/include/natalie_parser/node/interpolated_symbol_key_node.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "natalie_parser/node/interpolated_symbol_node.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class InterpolatedSymbolKeyNode : public InterpolatedSymbolNode {
+public:
+    InterpolatedSymbolKeyNode(const InterpolatedNode &other)
+        : InterpolatedSymbolNode { other } { }
+
+    virtual Type type() const override { return Type::InterpolatedSymbolKey; }
+
+    virtual bool is_symbol_key() const override { return true; }
+};
+}

data/include/natalie_parser/node/interpolated_symbol_node.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "natalie_parser/node/interpolated_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 InterpolatedSymbolNode : public InterpolatedNode {
+public:
+    InterpolatedSymbolNode(const Token &token)
+        : InterpolatedNode { token } { }
+
+    InterpolatedSymbolNode(const InterpolatedNode &other)
+        : InterpolatedNode { other.token() } {
+        for (auto node : other.nodes())
+            add_node(node);
+    }
+
+    virtual Type type() const override { return Type::InterpolatedSymbol; }
+
+    virtual void transform(Creator *creator) const override;
+};
+}

data/include/natalie_parser/node/iter_node.hpp

@@ -0,0 +1,45 @@
+#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/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class IterNode : public NodeWithArgs {
+public:
+    IterNode(const Token &token, SharedPtr<Node> call, bool has_args, const Vector<SharedPtr<Node>> &args, SharedPtr<BlockNode> body)
+        : NodeWithArgs { token, args }
+        , m_has_args { has_args }
+        , m_call { call }
+        , m_body { body } {
+        assert(m_call);
+        assert(m_body);
+    }
+
+    virtual Type type() const override { return Type::Iter; }
+
+    const SharedPtr<Node> call() const { return m_call; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("iter");
+        creator->append(m_call.ref());
+        if (m_has_args)
+            append_method_or_block_args(creator);
+        else
+            creator->append_integer(0);
+        if (!m_body->is_empty())
+            creator->append(m_body->without_unnecessary_nesting());
+    }
+
+protected:
+    bool m_has_args { false };
+    SharedPtr<Node> m_call {};
+    SharedPtr<BlockNode> m_body {};
+};
+}

data/include/natalie_parser/node/keyword_arg_node.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "natalie_parser/node/arg_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 KeywordArgNode : public ArgNode {
+public:
+    KeywordArgNode(const Token &token, SharedPtr<String> name)
+        : ArgNode { token, name } { }
+
+    virtual Type type() const override { return Type::KeywordArg; }
+
+    virtual void transform(Creator *creator) const override {
+        ArgNode::transform(creator);
+        creator->set_type("kwarg");
+    }
+};
+}

data/include/natalie_parser/node/keyword_splat_node.hpp

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

data/include/natalie_parser/node/logical_and_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 LogicalAndNode : public Node {
+public:
+    LogicalAndNode(const Token &token, SharedPtr<Node> left, SharedPtr<Node> right)
+        : Node { token }
+        , m_left { left }
+        , m_right { right } {
+        assert(m_left);
+        assert(m_right);
+    }
+
+    virtual Type type() const override { return Type::LogicalAnd; }
+
+    const SharedPtr<Node> left() const { return m_left; }
+    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("and");
+        creator->append(m_left.ref());
+        creator->append(m_right.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_left {};
+    SharedPtr<Node> m_right {};
+};
+}

data/include/natalie_parser/node/logical_or_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 LogicalOrNode : public Node {
+public:
+    LogicalOrNode(const Token &token, SharedPtr<Node> left, SharedPtr<Node> right)
+        : Node { token }
+        , m_left { left }
+        , m_right { right } {
+        assert(m_left);
+        assert(m_right);
+    }
+
+    virtual Type type() const override { return Type::LogicalOr; }
+
+    const SharedPtr<Node> left() const { return m_left; }
+    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("or");
+        creator->append(m_left.ref());
+        creator->append(m_right.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_left {};
+    SharedPtr<Node> m_right {};
+};
+}

data/include/natalie_parser/node/match_node.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/regexp_node.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class MatchNode : public Node {
+public:
+    MatchNode(const Token &token, SharedPtr<RegexpNode> regexp, SharedPtr<Node> arg, bool regexp_on_left)
+        : Node { token }
+        , m_regexp { regexp }
+        , m_arg { arg }
+        , m_regexp_on_left { regexp_on_left } {
+        assert(m_regexp);
+        assert(m_arg);
+    }
+
+    virtual Type type() const override { return Type::Match; }
+
+    const SharedPtr<RegexpNode> regexp() const { return m_regexp; }
+    const SharedPtr<Node> arg() const { return m_arg; }
+    bool regexp_on_left() const { return m_regexp_on_left; }
+
+    virtual void transform(Creator *creator) const override;
+
+protected:
+    SharedPtr<RegexpNode> m_regexp {};
+    SharedPtr<Node> m_arg {};
+    bool m_regexp_on_left { false };
+};
+}

data/include/natalie_parser/node/module_node.hpp

@@ -0,0 +1,32 @@
+#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 ModuleNode : public Node {
+public:
+    ModuleNode(const Token &token, SharedPtr<Node> name, SharedPtr<BlockNode> body)
+        : Node { token }
+        , m_name { name }
+        , m_body { body } { }
+
+    virtual Type type() const override { return Type::Module; }
+
+    const SharedPtr<Node> name() const { return m_name; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+
+    virtual void transform(Creator *creator) const override;
+
+protected:
+    SharedPtr<Node> m_name {};
+    SharedPtr<BlockNode> m_body {};
+};
+}

data/include/natalie_parser/node/multiple_assignment_arg_node.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "natalie_parser/node/arg_node.hpp"
+#include "natalie_parser/node/array_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 MultipleAssignmentArgNode : public ArrayNode {
+public:
+    MultipleAssignmentArgNode(const Token &token)
+        : ArrayNode { token } { }
+
+    virtual Type type() const override { return Type::MultipleAssignmentArg; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("masgn");
+        for (auto arg : nodes()) {
+            if (arg->type() == Node::Type::Arg) {
+                arg.static_cast_as<ArgNode>()->append_name(creator);
+            } else {
+                creator->append(arg);
+            }
+        }
+    }
+};
+}

data/include/natalie_parser/node/multiple_assignment_node.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "natalie_parser/node/array_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 MultipleAssignmentNode : public ArrayNode {
+public:
+    MultipleAssignmentNode(const Token &token)
+        : ArrayNode { token } { }
+
+    virtual Type type() const override { return Type::MultipleAssignment; }
+
+    virtual bool is_assignable() const override { return true; }
+
+    void add_locals(TM::Hashmap<TM::String> &);
+
+    virtual void transform(Creator *creator) const override {
+        creator->with_assignment(true, [&]() {
+            creator->set_type("masgn");
+            creator->append_array(*this);
+        });
+    }
+
+    int depth() { return m_depth; }
+    int increment_depth() { return ++m_depth; }
+
+private:
+    int m_depth { 0 };
+};
+}

data/include/natalie_parser/node/next_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 NextNode : public Node {
+public:
+    NextNode(const Token &token, SharedPtr<Node> arg = {})
+        : Node { token }
+        , m_arg { arg } {
+    }
+
+    virtual Type type() const override { return Type::Next; }
+
+    const Node &arg() const {
+        if (m_arg)
+            return m_arg.ref();
+        return Node::invalid();
+    }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("next");
+        if (m_arg)
+            creator->append(m_arg.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_arg {};
+};
+}

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

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

data/include/natalie_parser/node/node.hpp

@@ -0,0 +1,155 @@
+#pragma once
+
+#include "natalie_parser/creator.hpp"
+#include "natalie_parser/token.hpp"
+
+namespace NatalieParser {
+
+class NodeWithArgs;
+
+class BlockNode;
+
+class Node {
+public:
+    enum class Type {
+        Invalid,
+        Alias,
+        Arg,
+        Array,
+        ArrayPattern,
+        Assignment,
+        BackRef,
+        Begin,
+        BeginBlock,
+        BeginRescue,
+        Bignum,
+        Block,
+        BlockPass,
+        Break,
+        Call,
+        Case,
+        CaseIn,
+        CaseWhen,
+        Class,
+        Colon2,
+        Colon3,
+        Constant,
+        Def,
+        Defined,
+        Encoding,
+        EndBlock,
+        EvaluateToString,
+        False,
+        Fixnum,
+        Float,
+        Hash,
+        HashPattern,
+        Identifier,
+        If,
+        InfixOp,
+        Iter,
+        InterpolatedRegexp,
+        InterpolatedShell,
+        InterpolatedString,
+        InterpolatedSymbol,
+        InterpolatedSymbolKey,
+        KeywordArg,
+        KeywordSplat,
+        LogicalAnd,
+        LogicalOr,
+        Match,
+        Module,
+        MultipleAssignment,
+        MultipleAssignmentArg,
+        Next,
+        Nil,
+        NilSexp,
+        Not,
+        NotMatch,
+        NthRef,
+        OpAssign,
+        OpAssignAccessor,
+        OpAssignAnd,
+        OpAssignOr,
+        Pin,
+        Range,
+        Redo,
+        Regexp,
+        Retry,
+        Return,
+        SafeCall,
+        Sclass,
+        Self,
+        ShadowArg,
+        Shell,
+        Splat,
+        SplatValue,
+        StabbyProc,
+        String,
+        Super,
+        Symbol,
+        SymbolKey,
+        ToArray,
+        True,
+        UnaryOp,
+        Undef,
+        Until,
+        While,
+        Yield,
+    };
+
+    Node() { }
+
+    Node(const Token &token)
+        : m_token { token } { }
+
+    Node(const Node &) = delete;
+    Node &operator=(const Node &) = delete;
+
+    virtual ~Node() { }
+
+    virtual Type type() const { return Type::Invalid; }
+
+    virtual bool is_callable() const { return false; }
+    virtual bool is_assignable() const { return false; }
+    virtual bool is_numeric() const { return false; }
+    virtual bool is_symbol_key() const { return false; }
+    virtual bool can_accept_a_block() const { return false; }
+    virtual bool can_be_concatenated_to_a_string() const { return false; }
+    virtual bool has_block_pass() const { return false; }
+
+    BlockNode &as_block_node();
+
+    virtual void transform(Creator *creator) const {
+        creator->set_type("NOT_YET_IMPLEMENTED");
+        creator->append_integer((int)type());
+    }
+
+    SharedPtr<String> file() const { return m_token.file(); }
+
+    size_t line() const { return m_token.line(); }
+    void set_line(size_t line) { m_token.set_line(line); }
+
+    size_t column() const { return m_token.column(); }
+    void set_column(size_t column) { m_token.set_column(column); }
+
+    Optional<SharedPtr<String>> doc() const { return m_token.doc(); }
+
+    const Token &token() const { return m_token; }
+
+    const static Node &invalid() {
+        if (!s_invalid)
+            s_invalid = new Node;
+        return *s_invalid;
+    }
+
+    operator bool() const {
+        return type() != Type::Invalid;
+    }
+
+protected:
+    static inline SharedPtr<Node> s_invalid {};
+    Token m_token {};
+};
+
+}