natalie_parser 1.0.0

data/include/natalie_parser/node/constant_node.hpp

@@ -0,0 +1,26 @@
+#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 ConstantNode : public Node {
+public:
+    ConstantNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::Constant; }
+
+    SharedPtr<String> name() const { return m_token.literal_string(); }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("const");
+        creator->append_symbol(name());
+    }
+};
+}

data/include/natalie_parser/node/def_node.hpp

@@ -0,0 +1,55 @@
+#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 DefNode : public NodeWithArgs {
+public:
+    DefNode(const Token &token, SharedPtr<Node> self_node, SharedPtr<String> name, const Vector<SharedPtr<Node>> &args, SharedPtr<BlockNode> body)
+        : NodeWithArgs { token, args }
+        , m_self_node { self_node }
+        , m_name { name }
+        , m_body { body } {
+        assert(m_body);
+    }
+
+    virtual Type type() const override { return Type::Def; }
+
+    const SharedPtr<Node> self_node() const { return m_self_node; }
+    SharedPtr<String> name() const { return m_name; }
+    const SharedPtr<BlockNode> body() const { return m_body; }
+
+    virtual void transform(Creator *creator) const override {
+        if (m_self_node) {
+            creator->set_type("defs");
+            creator->append(m_self_node.ref());
+        } else {
+            creator->set_type("defn");
+        }
+        auto doc_comment = doc();
+        if (doc_comment)
+            creator->set_comments(doc_comment.value().ref());
+        creator->append_symbol(m_name);
+        append_method_or_block_args(creator);
+        if (m_body->is_empty()) {
+            creator->append_nil_sexp();
+        } else {
+            for (auto node : m_body->nodes())
+                creator->append(node);
+        }
+    }
+
+protected:
+    SharedPtr<Node> m_self_node {};
+    SharedPtr<String> m_name {};
+    SharedPtr<BlockNode> m_body {};
+};
+}

data/include/natalie_parser/node/defined_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 DefinedNode : public Node {
+public:
+    DefinedNode(const Token &token, SharedPtr<Node> arg)
+        : Node { token }
+        , m_arg { arg } {
+        assert(arg);
+    }
+
+    virtual Type type() const override { return Type::Defined; }
+
+    const SharedPtr<Node> arg() const { return m_arg; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("defined");
+        creator->append(m_arg.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_arg {};
+};
+}

data/include/natalie_parser/node/encoding_node.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class EncodingNode : public Node {
+public:
+    EncodingNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::Encoding; }
+
+    virtual void transform(Creator *creator) const override {
+        // s(:colon2, s(:const, :Encoding), :UTF_8)
+        creator->set_type("colon2");
+        creator->append_sexp([&](Creator *c) {
+            c->set_type("const");
+            c->append_symbol("Encoding");
+        });
+        creator->append_symbol("UTF_8"); // TODO: support file-encodings other than UTF-8
+    }
+};
+}

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

data/include/natalie_parser/node/evaluate_to_string_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 EvaluateToStringNode : public Node {
+public:
+    EvaluateToStringNode(const Token &token)
+        : Node { token } { }
+
+    EvaluateToStringNode(const Token &token, SharedPtr<Node> node)
+        : Node { token }
+        , m_node { node } {
+        assert(m_node);
+    }
+
+    virtual Type type() const override { return Type::EvaluateToString; }
+
+    const SharedPtr<Node> node() const { return m_node; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("evstr");
+        if (m_node)
+            creator->append(m_node);
+    }
+
+protected:
+    SharedPtr<Node> m_node {};
+};
+}

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

data/include/natalie_parser/node/fixnum_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 FixnumNode : public Node {
+public:
+    FixnumNode(const Token &token, long long number)
+        : Node { token }
+        , m_number { number } { }
+
+    virtual Type type() const override { return Type::Fixnum; }
+
+    virtual bool is_numeric() const override { return true; }
+
+    long long number() const { return m_number; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("lit");
+        creator->append_integer(m_number);
+    }
+
+    void negate() {
+        m_number *= -1;
+    }
+
+protected:
+    long long m_number;
+};
+}

data/include/natalie_parser/node/float_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 FloatNode : public Node {
+public:
+    FloatNode(const Token &token, double number)
+        : Node { token }
+        , m_number { number } { }
+
+    virtual Type type() const override { return Type::Float; }
+
+    virtual bool is_numeric() const override { return true; }
+
+    double number() const { return m_number; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("lit");
+        creator->append_float(m_number);
+    }
+
+    void negate() {
+        m_number *= -1;
+    }
+
+protected:
+    double m_number;
+};
+}

data/include/natalie_parser/node/hash_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 HashNode : public Node {
+public:
+    HashNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::Hash; }
+
+    void add_node(SharedPtr<Node> node) {
+        m_nodes.push(node);
+    }
+
+    const Vector<SharedPtr<Node>> &nodes() const { return m_nodes; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("hash");
+        for (auto node : m_nodes)
+            creator->append(node);
+    }
+
+protected:
+    Vector<SharedPtr<Node>> m_nodes {};
+};
+}

data/include/natalie_parser/node/hash_pattern_node.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "natalie_parser/node/hash_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 HashPatternNode : public HashNode {
+public:
+    HashPatternNode(const Token &token)
+        : HashNode { token } { }
+
+    virtual Type type() const override { return Type::HashPattern; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("hash_pat");
+        creator->append_nil(); // NOTE: I don't know what this nil is for
+        for (auto node : m_nodes)
+            creator->append(node);
+    }
+};
+}

data/include/natalie_parser/node/identifier_node.hpp

@@ -0,0 +1,123 @@
+#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 IdentifierNode : public Node {
+public:
+    IdentifierNode(const Token &token, bool is_lvar)
+        : Node { token }
+        , m_is_lvar { is_lvar } { }
+
+    virtual Type type() const override { return Type::Identifier; }
+
+    virtual bool is_assignable() const override { return true; }
+    virtual bool can_accept_a_block() const override { return true; }
+
+    Token::Type token_type() const { return m_token.type(); }
+
+    SharedPtr<String> name() const { return m_token.literal_string(); }
+
+    void prepend_to_name(char c) {
+        auto literal = m_token.literal_string();
+        literal->prepend_char(c);
+        // FIXME: set_literal() unneeded?
+        m_token.set_literal(literal);
+    }
+
+    void append_to_name(char c) {
+        auto literal = m_token.literal_string();
+        literal->append_char(c);
+        // FIXME: set_literal() unneeded?
+        m_token.set_literal(literal);
+    }
+
+    virtual bool is_callable() const override {
+        switch (token_type()) {
+        case Token::Type::BareName:
+        case Token::Type::Constant:
+            return !m_is_lvar;
+        default:
+            return false;
+        }
+    }
+
+    bool is_lvar() const { return m_is_lvar; }
+    void set_is_lvar(bool is_lvar) { m_is_lvar = is_lvar; }
+
+    void add_to_locals(TM::Hashmap<TM::String> &locals) const {
+        if (token_type() == Token::Type::BareName)
+            locals.set(name()->c_str());
+    }
+
+    virtual void transform(Creator *creator) const override {
+        if (creator->assignment())
+            return transform_assignment(creator);
+        switch (token_type()) {
+        case Token::Type::BareName:
+            if (is_lvar()) {
+                creator->set_type("lvar");
+                creator->append_symbol(name());
+            } else {
+                creator->set_type("call");
+                creator->append_nil();
+                creator->append_symbol(name());
+            }
+            break;
+        case Token::Type::ClassVariable:
+            creator->set_type("cvar");
+            creator->append_symbol(name());
+            break;
+        case Token::Type::Constant:
+            creator->set_type("const");
+            creator->append_symbol(name());
+            break;
+        case Token::Type::GlobalVariable: {
+            creator->set_type("gvar");
+            creator->append_symbol(name());
+            break;
+        }
+        case Token::Type::InstanceVariable:
+            creator->set_type("ivar");
+            creator->append_symbol(name());
+            break;
+        default:
+            TM_UNREACHABLE();
+        }
+    }
+
+    void transform_assignment(Creator *creator) const {
+        switch (token().type()) {
+        case Token::Type::BareName:
+            creator->set_type("lasgn");
+            break;
+        case Token::Type::ClassVariable:
+            creator->set_type("cvdecl");
+            break;
+        case Token::Type::Constant:
+        case Token::Type::ConstantResolution:
+            creator->set_type("cdecl");
+            break;
+        case Token::Type::GlobalVariable:
+            creator->set_type("gasgn");
+            break;
+        case Token::Type::InstanceVariable:
+            creator->set_type("iasgn");
+            break;
+        default:
+            printf("got token type %d\n", (int)token().type());
+            TM_UNREACHABLE();
+        }
+        creator->append_symbol(name());
+    }
+
+protected:
+    bool m_is_lvar { false };
+};
+}

data/include/natalie_parser/node/if_node.hpp

@@ -0,0 +1,43 @@
+#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 IfNode : public Node {
+public:
+    IfNode(const Token &token, SharedPtr<Node> condition, SharedPtr<Node> true_expr, SharedPtr<Node> false_expr)
+        : Node { token }
+        , m_condition { condition }
+        , m_true_expr { true_expr }
+        , m_false_expr { false_expr } {
+        assert(m_condition);
+        assert(m_true_expr);
+        assert(m_false_expr);
+    }
+
+    virtual Type type() const override { return Type::If; }
+
+    const SharedPtr<Node> condition() const { return m_condition; }
+    const SharedPtr<Node> true_expr() const { return m_true_expr; }
+    const SharedPtr<Node> false_expr() const { return m_false_expr; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("if");
+        creator->append(m_condition.ref());
+        creator->append(m_true_expr.ref());
+        creator->append(m_false_expr.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_condition {};
+    SharedPtr<Node> m_true_expr {};
+    SharedPtr<Node> m_false_expr {};
+};
+}

data/include/natalie_parser/node/infix_op_node.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "tm/owned_ptr.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class InfixOpNode : public Node {
+public:
+    InfixOpNode(const Token &token, SharedPtr<Node> left, SharedPtr<String> op, SharedPtr<Node> right)
+        : Node { token }
+        , m_left { left }
+        , m_op { op }
+        , m_right { right } {
+        assert(m_left);
+        assert(m_op);
+        assert(m_right);
+    }
+
+    virtual Type type() const override { return Type::InfixOp; }
+
+    virtual bool is_callable() const override { return true; }
+    virtual bool can_accept_a_block() const override { return false; }
+
+    const SharedPtr<Node> left() const { return m_left; }
+    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_left.ref());
+        creator->append_symbol(m_op);
+        creator->append(m_right.ref());
+    }
+
+protected:
+    SharedPtr<Node> m_left {};
+    SharedPtr<String> m_op {};
+    SharedPtr<Node> m_right {};
+};
+}

data/include/natalie_parser/node/interpolated_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/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class InterpolatedNode : public Node {
+public:
+    InterpolatedNode(const Token &token)
+        : Node { token } { }
+
+    InterpolatedNode(const InterpolatedNode &other)
+        : Node { other.token() } {
+        for (auto node : other.nodes())
+            add_node(node);
+    }
+
+    bool is_empty() const { return m_nodes.is_empty(); }
+
+    void prepend_node(SharedPtr<Node> node) { m_nodes.push_front(node); };
+    void add_node(SharedPtr<Node> node) { m_nodes.push(node); };
+
+    const Vector<SharedPtr<Node>> &nodes() const { return m_nodes; }
+
+protected:
+    Vector<SharedPtr<Node>> m_nodes {};
+};
+}

data/include/natalie_parser/node/interpolated_regexp_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 InterpolatedRegexpNode : public InterpolatedNode {
+public:
+    InterpolatedRegexpNode(const Token &token)
+        : InterpolatedNode { token } { }
+
+    virtual Type type() const override { return Type::InterpolatedRegexp; }
+
+    int options() const { return m_options; }
+    void set_options(int options) { m_options = options; }
+
+    virtual void transform(Creator *creator) const override;
+
+private:
+    int m_options { 0 };
+};
+}

data/include/natalie_parser/node/interpolated_shell_node.hpp

@@ -0,0 +1,22 @@
+#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 InterpolatedShellNode : public InterpolatedNode {
+public:
+    InterpolatedShellNode(const Token &token)
+        : InterpolatedNode { token } { }
+
+    virtual Type type() const override { return Type::InterpolatedShell; }
+
+    virtual void transform(Creator *creator) const override;
+};
+}