natalie_parser 1.0.0

data/src/node/alias_node.cpp

@@ -0,0 +1,11 @@
+#include "natalie_parser/node/alias_node.hpp"
+
+namespace NatalieParser {
+
+void AliasNode::transform(Creator *creator) const {
+    creator->set_type("alias");
+    creator->append(m_new_name.ref());
+    creator->append(m_existing_name.ref());
+}
+
+}

data/src/node/assignment_node.cpp

@@ -0,0 +1,33 @@
+#include "natalie_parser/node/assignment_node.hpp"
+#include "natalie_parser/node/multiple_assignment_node.hpp"
+
+namespace NatalieParser {
+
+void AssignmentNode::transform(Creator *creator) const {
+    creator->set_line(m_identifier->line());
+    creator->set_column(m_identifier->column());
+    creator->reset_sexp();
+    switch (m_identifier->type()) {
+    case Node::Type::MultipleAssignment: {
+        auto masgn = m_identifier;
+        masgn->transform(creator);
+        creator->append(m_value.ref());
+        break;
+    }
+    case Node::Type::Call:
+    case Node::Type::Colon2:
+    case Node::Type::Colon3:
+    case Node::Type::Identifier:
+    case Node::Type::SafeCall: {
+        creator->with_assignment(true, [&]() {
+            m_identifier->transform(creator);
+        });
+        creator->append(m_value.ref());
+        break;
+    }
+    default:
+        TM_UNREACHABLE();
+    }
+}
+
+}

data/src/node/begin_node.cpp

@@ -0,0 +1,29 @@
+#include "natalie_parser/node/begin_node.hpp"
+
+namespace NatalieParser {
+
+void BeginNode::transform(Creator *creator) const {
+    assert(m_body);
+    creator->set_type("rescue");
+    if (!m_body->is_empty())
+        creator->append(m_body->without_unnecessary_nesting());
+    for (auto rescue_node : m_rescue_nodes) {
+        creator->append(rescue_node.static_cast_as<Node>());
+    }
+    if (m_else_body) {
+        if (!m_else_body->is_empty())
+            creator->append(m_else_body->without_unnecessary_nesting());
+    }
+    if (m_ensure_body) {
+        if (m_rescue_nodes.is_empty())
+            creator->set_type("ensure");
+        else
+            creator->wrap("ensure");
+        if (m_ensure_body->is_empty())
+            creator->append_nil_sexp();
+        else
+            creator->append(m_ensure_body->without_unnecessary_nesting());
+    }
+}
+
+}

data/src/node/begin_rescue_node.cpp

@@ -0,0 +1,33 @@
+#include "natalie_parser/node/begin_rescue_node.hpp"
+#include "natalie_parser/node/array_node.hpp"
+#include "natalie_parser/node/assignment_node.hpp"
+
+namespace NatalieParser {
+
+SharedPtr<Node> BeginRescueNode::name_to_node() const {
+    assert(m_name);
+    return new AssignmentNode {
+        token(),
+        m_name.static_cast_as<Node>(),
+        new IdentifierNode {
+            Token { Token::Type::GlobalVariable, "$!", file(), line(), column() },
+            false },
+    };
+}
+
+void BeginRescueNode::transform(Creator *creator) const {
+    creator->set_type("resbody");
+    auto array = ArrayNode { token() };
+    for (auto exception_node : m_exceptions)
+        array.add_node(exception_node);
+    if (m_name)
+        array.add_node(name_to_node());
+    creator->append(array);
+    if (m_body->nodes().is_empty())
+        creator->append_nil();
+    else
+        for (auto node : m_body->nodes())
+            creator->append(node);
+}
+
+}

data/src/node/class_node.cpp

@@ -0,0 +1,22 @@
+#include "natalie_parser/node/class_node.hpp"
+#include "natalie_parser/node/identifier_node.hpp"
+
+namespace NatalieParser {
+
+void ClassNode::transform(Creator *creator) const {
+    creator->set_type("class");
+    auto doc_comment = doc();
+    if (doc_comment)
+        creator->set_comments(doc_comment.value().ref());
+    if (m_name->type() == Node::Type::Identifier) {
+        auto identifier = m_name.static_cast_as<IdentifierNode>();
+        creator->append_symbol(identifier->name());
+    } else {
+        creator->append(m_name.ref());
+    }
+    creator->append(m_superclass.ref());
+    for (auto node : m_body->nodes())
+        creator->append(node);
+}
+
+}

data/src/node/interpolated_regexp_node.cpp

@@ -0,0 +1,19 @@
+#include "natalie_parser/node/interpolated_regexp_node.hpp"
+#include "natalie_parser/node/string_node.hpp"
+
+namespace NatalieParser {
+
+void InterpolatedRegexpNode::transform(Creator *creator) const {
+    creator->set_type("dregx");
+    for (size_t i = 0; i < nodes().size(); ++i) {
+        auto node = nodes()[i];
+        if (i == 0 && node->type() == Node::Type::String)
+            creator->append_string(node.static_cast_as<StringNode>()->string());
+        else
+            creator->append(node);
+    }
+    if (m_options != 0)
+        creator->append_integer(m_options);
+}
+
+}

data/src/node/interpolated_shell_node.cpp

@@ -0,0 +1,25 @@
+#include "natalie_parser/node/interpolated_shell_node.hpp"
+#include "natalie_parser/node/string_node.hpp"
+
+namespace NatalieParser {
+
+void InterpolatedShellNode::transform(Creator *creator) const {
+    creator->set_type("dxstr");
+    bool has_starter_string = false;
+    for (size_t i = 0; i < m_nodes.size(); ++i) {
+        auto node = m_nodes.at(i);
+        if (i == 0 && node->type() == Node::Type::String) {
+            auto string_node = node.static_cast_as<StringNode>();
+            creator->append_string(string_node->string());
+            has_starter_string = true;
+        } else {
+            if (!has_starter_string) {
+                creator->append_string("");
+                has_starter_string = true;
+            }
+            creator->append(node);
+        }
+    }
+}
+
+}

data/src/node/interpolated_string_node.cpp

@@ -0,0 +1,111 @@
+#include "natalie_parser/node/interpolated_string_node.hpp"
+#include "natalie_parser/node/evaluate_to_string_node.hpp"
+#include "natalie_parser/node/string_node.hpp"
+
+namespace NatalieParser {
+
+SharedPtr<Node> InterpolatedStringNode::append_string_node(SharedPtr<Node> string2) const {
+    SharedPtr<InterpolatedStringNode> copy = new InterpolatedStringNode { *this };
+    switch (string2->type()) {
+    case Node::Type::String: {
+        auto string2_node = string2.static_cast_as<StringNode>();
+        assert(!is_empty());
+        auto last_node = copy->nodes().last();
+        switch (last_node->type()) {
+        case Node::Type::String:
+            if (m_nodes.size() > 1) {
+                // For some reason, RubyParser doesn't append two string nodes
+                // if there is an evstr present.
+                copy->add_node(string2);
+            } else {
+                // NOTE: This mutates one of my own nodes, but I don't care.
+                last_node.static_cast_as<StringNode>()->string()->append(*string2_node->string());
+            }
+            break;
+        case Node::Type::EvaluateToString:
+            copy->add_node(string2);
+            break;
+        default:
+            TM_UNREACHABLE();
+        }
+        return copy.static_cast_as<Node>();
+    }
+    case Node::Type::InterpolatedString: {
+        auto string2_node = string2.static_cast_as<InterpolatedStringNode>();
+        assert(!is_empty());
+        assert(!string2_node->is_empty());
+        for (auto node : string2_node->nodes()) {
+            copy->add_node(node);
+        }
+        return copy.static_cast_as<Node>();
+    }
+    default:
+        TM_UNREACHABLE();
+    }
+}
+
+void InterpolatedStringNode::transform(Creator *creator) const {
+    creator->set_type("dstr");
+
+    bool has_starter_string = false;
+    bool only_static = true;
+
+    for (size_t i = 0; i < m_nodes.size(); ++i) {
+        auto node = m_nodes.at(i);
+
+        // the first item is always a literal string
+        if (i == 0 && node->type() == Node::Type::String) {
+            auto string = node.static_cast_as<StringNode>()->string();
+
+            // append consecutive static strings to this one
+            while (i + 1 < m_nodes.size() && m_nodes.at(i + 1)->type() == Node::Type::String) {
+                auto n = m_nodes[++i];
+                string = new String(*string);
+                string->append(*n.static_cast_as<StringNode>()->string());
+            }
+
+            creator->append_string(string);
+            has_starter_string = true;
+
+        } else {
+            only_static = false;
+
+            // if we don't have a static string to start, append a blank one
+            // (this is what RubyParser does and we mimic it)
+            if (!has_starter_string) {
+                creator->append_string("");
+                has_starter_string = true;
+            }
+
+            // if this node is an InterpolatedString having a single
+            // EvaluateToString node, then yoink the EvaluateToString
+            // for ourselves, and don't bother with the useless wrapper
+            //
+            //     # bad
+            //     s(:dstr, "", s(:evstr, s(:dstr, "", s(:evstr, s(:lit, 1)))))
+            //
+            //     # good
+            //     s(:dstr, "", s(:evstr, s(:lit, 1)))
+            //
+            if (node->type() == Node::Type::EvaluateToString) {
+                auto evstr = node.static_cast_as<EvaluateToStringNode>();
+                if (evstr->node() && evstr->node()->type() == Node::Type::InterpolatedString) {
+                    auto dstr = evstr->node().static_cast_as<InterpolatedStringNode>();
+                    if (dstr->nodes().size() == 1 && dstr->nodes().first()->type() == Node::Type::EvaluateToString) {
+                        auto n1 = dstr->nodes().first().static_cast_as<EvaluateToStringNode>();
+                        creator->append(dstr->nodes().first());
+                        continue;
+                    }
+                }
+            }
+
+            creator->append(node);
+        }
+    }
+
+    // if we only appended static strings, then this isn't a dstr
+    if (only_static)
+        creator->set_type("str");
+}
+
+}

data/src/node/interpolated_symbol_node.cpp

@@ -0,0 +1,25 @@
+#include "natalie_parser/node/interpolated_symbol_node.hpp"
+#include "natalie_parser/node/string_node.hpp"
+
+namespace NatalieParser {
+
+void InterpolatedSymbolNode::transform(Creator *creator) const {
+    creator->set_type("dsym");
+    bool has_starter_string = false;
+    for (size_t i = 0; i < m_nodes.size(); ++i) {
+        auto node = m_nodes.at(i);
+        if (i == 0 && node->type() == Node::Type::String) {
+            auto string_node = node.static_cast_as<StringNode>();
+            creator->append_string(string_node->string());
+            has_starter_string = true;
+        } else {
+            if (!has_starter_string) {
+                creator->append_string("");
+                has_starter_string = true;
+            }
+            creator->append(node);
+        }
+    }
+}
+
+}

data/src/node/match_node.cpp

@@ -0,0 +1,14 @@
+#include "natalie_parser/node/match_node.hpp"
+
+namespace NatalieParser {
+
+void MatchNode::transform(Creator *creator) const {
+    if (m_regexp_on_left)
+        creator->set_type("match2");
+    else
+        creator->set_type("match3");
+    creator->append(m_regexp.ref());
+    creator->append(m_arg.ref());
+}
+
+}

data/src/node/module_node.cpp

@@ -0,0 +1,21 @@
+#include "natalie_parser/node/module_node.hpp"
+#include "natalie_parser/node/identifier_node.hpp"
+
+namespace NatalieParser {
+
+void ModuleNode::transform(Creator *creator) const {
+    creator->set_type("module");
+    auto doc_comment = doc();
+    if (doc_comment)
+        creator->set_comments(doc_comment.value().ref());
+    if (m_name->type() == Node::Type::Identifier) {
+        auto identifier = m_name.static_cast_as<IdentifierNode>();
+        creator->append_symbol(identifier->name());
+    } else {
+        creator->append(m_name.ref());
+    }
+    for (auto node : m_body->nodes())
+        creator->append(node);
+}
+
+}

data/src/node/multiple_assignment_node.cpp

@@ -0,0 +1,37 @@
+#include "natalie_parser/node/multiple_assignment_node.hpp"
+#include "natalie_parser/node/identifier_node.hpp"
+#include "natalie_parser/node/splat_node.hpp"
+
+namespace NatalieParser {
+
+void MultipleAssignmentNode::add_locals(TM::Hashmap<TM::String> &locals) {
+    for (auto node : m_nodes) {
+        switch (node->type()) {
+        case Node::Type::Identifier: {
+            auto identifier = node.static_cast_as<IdentifierNode>();
+            identifier->add_to_locals(locals);
+            break;
+        }
+        case Node::Type::Call:
+        case Node::Type::Colon2:
+        case Node::Type::Colon3:
+            break;
+        case Node::Type::Splat: {
+            auto splat = node.static_cast_as<SplatNode>();
+            if (splat->node() && splat->node()->type() == Node::Type::Identifier) {
+                auto identifier = splat->node().static_cast_as<IdentifierNode>();
+                identifier->add_to_locals(locals);
+            }
+            break;
+        }
+        case Node::Type::MultipleAssignment:
+            node.static_cast_as<MultipleAssignmentNode>()->add_locals(locals);
+            break;
+        default:
+            printf("unknown node type %d\n", (int)node->type());
+            TM_UNREACHABLE();
+        }
+    }
+}
+
+}

data/src/node/node.cpp

@@ -0,0 +1,10 @@
+#include "natalie_parser/node.hpp"
+
+namespace NatalieParser {
+
+BlockNode &Node::as_block_node() {
+    assert(type() == Node::Type::Block);
+    return *static_cast<BlockNode *>(this);
+}
+
+}

data/src/node/node_with_args.cpp

@@ -0,0 +1,35 @@
+#include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/arg_node.hpp"
+#include "natalie_parser/node/shadow_arg_node.hpp"
+
+namespace NatalieParser {
+
+void NodeWithArgs::append_method_or_block_args(Creator *creator) const {
+    creator->append_sexp([&](Creator *c) {
+        c->set_type("args");
+        for (auto arg : m_args) {
+            switch (arg->type()) {
+            case Node::Type::Arg: {
+                auto arg_node = arg.static_cast_as<ArgNode>();
+                if (arg_node->value())
+                    c->append(arg);
+                else
+                    arg.static_cast_as<ArgNode>()->append_name(c);
+                break;
+            }
+            case Node::Type::KeywordArg:
+            case Node::Type::MultipleAssignmentArg:
+            case Node::Type::ShadowArg:
+                c->append(arg);
+                break;
+            case Node::Type::Nil:
+                c->append_nil();
+                break;
+            default:
+                TM_UNREACHABLE();
+            }
+        }
+    });
+}
+
+}

data/src/node/op_assign_node.cpp

@@ -0,0 +1,36 @@
+#include "natalie_parser/node/op_assign_node.hpp"
+#include "natalie_parser/node/identifier_node.hpp"
+
+namespace NatalieParser {
+
+void OpAssignNode::transform(Creator *creator) const {
+    assert(m_op);
+    switch (m_name->type()) {
+    case Node::Type::Identifier: {
+        auto identifier_node = m_name.static_cast_as<IdentifierNode>();
+        creator->with_assignment(true, [&]() {
+            identifier_node->transform(creator);
+        });
+        auto value = CallNode {
+            token(),
+            m_name.static_cast_as<Node>(),
+            m_op
+        };
+        value.add_arg(m_value);
+        creator->append(value);
+        break;
+    }
+    case Node::Type::Colon2:
+    case Node::Type::Colon3:
+        creator->set_type("op_asgn");
+        creator->append(m_name);
+        creator->append_symbol(m_op);
+        creator->append(m_value);
+        break;
+    default:
+        printf("got node type %d\n", (int)m_name->type());
+        TM_UNREACHABLE();
+    }
+}
+
+}

data/src/node/string_node.cpp

@@ -0,0 +1,33 @@
+#include "natalie_parser/node/string_node.hpp"
+#include "natalie_parser/node/interpolated_string_node.hpp"
+
+namespace NatalieParser {
+
+SharedPtr<Node> StringNode::append_string_node(SharedPtr<Node> string2) const {
+    switch (string2->type()) {
+    case Node::Type::String: {
+        auto string2_node = string2.static_cast_as<StringNode>();
+        SharedPtr<String> str = new String { *m_string };
+        str->append(*string2_node->string());
+        return new StringNode { m_token, str };
+    }
+    case Node::Type::InterpolatedString: {
+        auto string2_node = string2.static_cast_as<InterpolatedStringNode>();
+        assert(!string2_node->is_empty());
+        if (string2_node->nodes().first()->type() == Node::Type::String) {
+            auto n1 = string2_node->nodes().first().static_cast_as<StringNode>();
+            n1->string()->prepend(*m_string);
+        } else {
+            auto copy = new StringNode(m_token, m_string);
+            string2_node->prepend_node(copy);
+        }
+        string2->set_line(line());
+        string2->set_column(column());
+        return string2;
+    }
+    default:
+        TM_UNREACHABLE();
+    }
+}
+
+}