Move CRuby-specific prism files to top level

2 files changed, 0 insertions, 2185 deletions

diff --git a/prism/prism_compiler.c b/prism/prism_compiler.c
deleted file mode 100644
index 7247d701bd..0000000000
--- a/prism/prism_compiler.c
+++ /dev/null
@@ -1,2176 +0,0 @@
-#include "prism.h"
-
-#define OLD_ISEQ NEW_ISEQ
-#undef NEW_ISEQ
-
-#define NEW_ISEQ(node, name, type, line_no) \
-    pm_new_child_iseq(iseq, (node), parser, rb_fstring(name), 0, (type), (line_no))
-
-#define OLD_CHILD_ISEQ NEW_CHILD_ISEQ
-#undef NEW_CHILD_ISEQ
-
-#define NEW_CHILD_ISEQ(node, name, type, line_no) \
-    pm_new_child_iseq(iseq, (node), parser, rb_fstring(name), iseq, (type), (line_no))
-
-#define PM_COMPILE(node) \
-    pm_compile_node(iseq, (node), ret, src, popped, compile_context)
-
-#define PM_COMPILE_POPPED(node) \
-    pm_compile_node(iseq, (node), ret, src, true, compile_context)
-
-#define PM_COMPILE_NOT_POPPED(node) \
-    pm_compile_node(iseq, (node), ret, src, false, compile_context)
-
-#define PM_POP_IF_POPPED \
-    if (popped) ADD_INSN(ret, &dummy_line_node, pop);
-
-#define PM_POP_UNLESS_POPPED \
-    if (!popped) ADD_INSN(ret, &dummy_line_node, pop);
-
-#define PM_DUP_UNLESS_POPPED \
-    if (!popped) ADD_INSN(ret, &dummy_line_node, dup);
-
-#define PM_PUTNIL_UNLESS_POPPED \
-    if (!popped) ADD_INSN(ret, &dummy_line_node, putnil);
-
-rb_iseq_t *
-pm_iseq_new_with_opt(pm_scope_node_t *node, pm_parser_t *parser, VALUE name, VALUE path, VALUE realpath,
-                     int first_lineno, const rb_iseq_t *parent, int isolated_depth,
-                     enum rb_iseq_type type, const rb_compile_option_t *option);
-
-static VALUE
-parse_integer(const pm_integer_node_t *node)
-{
-    const char *start = (const char *) node->base.location.start;
-    const char *end = (const char *) node->base.location.end;
-
-    size_t length = end - start;
-    int base = -10;
-
-    switch (node->base.flags & (PM_INTEGER_BASE_FLAGS_BINARY | PM_INTEGER_BASE_FLAGS_DECIMAL | PM_INTEGER_BASE_FLAGS_OCTAL | PM_INTEGER_BASE_FLAGS_HEXADECIMAL)) {
-        case PM_INTEGER_BASE_FLAGS_BINARY:
-            base = 2;
-            break;
-        case PM_INTEGER_BASE_FLAGS_DECIMAL:
-            base = 10;
-            break;
-        case PM_INTEGER_BASE_FLAGS_OCTAL:
-            base = 8;
-            break;
-        case PM_INTEGER_BASE_FLAGS_HEXADECIMAL:
-            base = 16;
-            break;
-        default:
-            rb_bug("Unexpected integer base");
-    }
-
-    return rb_int_parse_cstr(start, length, NULL, NULL, base, RB_INT_PARSE_DEFAULT);
-}
-
-static VALUE
-parse_float(const pm_node_t *node)
-{
-    const uint8_t *start = node->location.start;
-    const uint8_t *end = node->location.end;
-    size_t length = end - start;
-
-    char *buffer = malloc(length + 1);
-    memcpy(buffer, start, length);
-
-    buffer[length] = '\0';
-    VALUE number = DBL2NUM(rb_cstr_to_dbl(buffer, 0));
-
-    free(buffer);
-    return number;
-}
-
-static VALUE
-parse_rational(const pm_node_t *node)
-{
-    const uint8_t *start = node->location.start;
-    const uint8_t *end = node->location.end - 1;
-    size_t length = end - start;
-
-    VALUE res;
-    if (PM_NODE_TYPE_P(((pm_rational_node_t *)node)->numeric, PM_FLOAT_NODE)) {
-        char *buffer = malloc(length + 1);
-        memcpy(buffer, start, length);
-
-        buffer[length] = '\0';
-
-        char *decimal = memchr(buffer, '.', length);
-        RUBY_ASSERT(decimal);
-        size_t seen_decimal = decimal - buffer;
-        size_t fraclen = length - seen_decimal - 1;
-        memmove(decimal, decimal + 1, fraclen + 1);
-
-        VALUE v = rb_cstr_to_inum(buffer, 10, false);
-        res = rb_rational_new(v, rb_int_positive_pow(10, fraclen));
-
-        free(buffer);
-    }
-    else {
-        RUBY_ASSERT(PM_NODE_TYPE_P(((pm_rational_node_t *)node)->numeric, PM_INTEGER_NODE));
-        VALUE number = rb_int_parse_cstr((const char *)start, length, NULL, NULL, -10, RB_INT_PARSE_DEFAULT);
-        res = rb_rational_raw(number, INT2FIX(1));
-    }
-
-    return res;
-}
-
-static VALUE
-parse_imaginary(pm_imaginary_node_t *node)
-{
-    VALUE imaginary_part;
-    switch (PM_NODE_TYPE(node->numeric)) {
-      case PM_FLOAT_NODE: {
-          imaginary_part = parse_float(node->numeric);
-          break;
-      }
-      case PM_INTEGER_NODE: {
-          imaginary_part = parse_integer((pm_integer_node_t *) node->numeric);
-          break;
-      }
-      case PM_RATIONAL_NODE: {
-          imaginary_part = parse_rational(node->numeric);
-          break;
-      }
-      default:
-        rb_bug("Unexpected numeric type on imaginary number");
-    }
-
-    return rb_complex_raw(INT2FIX(0), imaginary_part);
-}
-
-static inline VALUE
-parse_string(pm_string_t *string)
-{
-    return rb_str_new((const char *) pm_string_source(string), pm_string_length(string));
-}
-
-static inline ID
-parse_symbol(const uint8_t *start, const uint8_t *end)
-{
-    return rb_intern2((const char *) start, end - start);
-}
-
-static inline ID
-parse_string_symbol(pm_string_t *string) {
-    const uint8_t *start = pm_string_source(string);
-    return parse_symbol(start, start + pm_string_length(string));
-}
-
-static inline ID
-parse_location_symbol(pm_location_t *location) {
-    return parse_symbol(location->start, location->end);
-}
-
-static int
-pm_optimizable_range_item_p(pm_node_t *node)
-{
-    return (!node || PM_NODE_TYPE_P(node, PM_INTEGER_NODE) || PM_NODE_TYPE_P(node, PM_NIL_NODE));
-}
-
-/**
- * Certain nodes can be compiled literally, which can lead to further
- * optimizations. These nodes will all have the PM_NODE_FLAG_STATIC_LITERAL flag
- * set.
- */
-static inline bool
-pm_static_node_literal_p(pm_node_t *node) {
-    return node->flags & PM_NODE_FLAG_STATIC_LITERAL;
-}
-
-static inline VALUE
-pm_static_literal_value(pm_node_t *node)
-{
-    switch(PM_NODE_TYPE(node)) {
-      case PM_FALSE_NODE:
-        return Qfalse;
-      case PM_FLOAT_NODE:
-        return parse_float(node);
-      case PM_IMAGINARY_NODE:
-        return parse_imaginary((pm_imaginary_node_t *)node);
-      case PM_INTEGER_NODE:
-        return parse_integer((pm_integer_node_t *) node);
-      case PM_NIL_NODE:
-        return Qnil;
-      case PM_RATIONAL_NODE:
-        return parse_rational(node);
-      case PM_STRING_NODE:
-        return parse_string(&((pm_string_node_t *)node)->unescaped);
-      case PM_SYMBOL_NODE:
-        return ID2SYM(parse_string_symbol(&((pm_symbol_node_t *)node)->unescaped));
-      case PM_TRUE_NODE:
-        return Qtrue;
-        // TODO: Implement this method for the other literal nodes described above
-      default:
-        rb_raise(rb_eArgError, "Don't have a literal value for this type");
-        return Qfalse;
-    }
-}
-
-static void
-pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_node_t *cond,
-                         LABEL *then_label, LABEL *else_label, const uint8_t *src, bool popped, pm_compile_context_t *compile_context);
-
-static void
-pm_compile_logical(rb_iseq_t *iseq, LINK_ANCHOR *const ret, pm_node_t *cond,
-                LABEL *then_label, LABEL *else_label, const uint8_t *src, bool popped, pm_compile_context_t *compile_context)
-{
-    pm_parser_t *parser = compile_context->parser;
-    pm_newline_list_t newline_list = parser->newline_list;
-    int lineno = (int)pm_newline_list_line_column(&newline_list, cond->location.start).line;
-    NODE dummy_line_node = generate_dummy_line_node(lineno, lineno);
-
-    DECL_ANCHOR(seq);
-    INIT_ANCHOR(seq);
-    LABEL *label = NEW_LABEL(lineno);
-    if (!then_label) then_label = label;
-    else if (!else_label) else_label = label;
-
-    pm_compile_branch_condition(iseq, seq, cond, then_label, else_label, src, popped, compile_context);
-
-    if (LIST_INSN_SIZE_ONE(seq)) {
-        INSN *insn = (INSN *)ELEM_FIRST_INSN(FIRST_ELEMENT(seq));
-        if (insn->insn_id == BIN(jump) && (LABEL *)(insn->operands[0]) == label)
-            return;
-    }
-    if (!label->refcnt) {
-        ADD_INSN(seq, &dummy_line_node, putnil);
-    }
-    else {
-        ADD_LABEL(seq, label);
-    }
-    ADD_SEQ(ret, seq);
-    return;
-}
-
-static void pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, pm_compile_context_t *context);
-
-static void
-pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_node_t *cond,
-                         LABEL *then_label, LABEL *else_label, const uint8_t *src, bool popped, pm_compile_context_t *compile_context)
-{
-    pm_parser_t *parser = compile_context->parser;
-    pm_newline_list_t newline_list = parser->newline_list;
-    int lineno = (int) pm_newline_list_line_column(&newline_list, cond->location.start).line;
-    NODE dummy_line_node = generate_dummy_line_node(lineno, lineno);
-
-again:
-    switch (PM_NODE_TYPE(cond)) {
-      case PM_AND_NODE: {
-          pm_and_node_t *and_node = (pm_and_node_t *)cond;
-          pm_compile_logical(iseq, ret, and_node->left, NULL, else_label, src, popped, compile_context);
-          cond = and_node->right;
-          goto again;
-      }
-      case PM_OR_NODE: {
-          pm_or_node_t *or_node = (pm_or_node_t *)cond;
-          pm_compile_logical(iseq, ret, or_node->left, then_label, NULL, src, popped, compile_context);
-          cond = or_node->right;
-          goto again;
-      }
-      case PM_FALSE_NODE:
-      case PM_NIL_NODE:
-        ADD_INSNL(ret, &dummy_line_node, jump, else_label);
-        return;
-      case PM_FLOAT_NODE:
-      case PM_IMAGINARY_NODE:
-      case PM_INTEGER_NODE:
-      case PM_LAMBDA_NODE:
-      case PM_RATIONAL_NODE:
-      case PM_REGULAR_EXPRESSION_NODE:
-      case PM_STRING_NODE:
-      case PM_SYMBOL_NODE:
-      case PM_TRUE_NODE:
-        ADD_INSNL(ret, &dummy_line_node, jump, then_label);
-        return;
-        // TODO: Several more nodes in this case statement
-      default:
-        {
-            DECL_ANCHOR(cond_seq);
-            INIT_ANCHOR(cond_seq);
-
-            pm_compile_node(iseq, cond, cond_seq, src, false, compile_context);
-            ADD_SEQ(ret, cond_seq);
-        }
-        break;
-    }
-    ADD_INSNL(ret, &dummy_line_node, branchunless, else_label);
-    ADD_INSNL(ret, &dummy_line_node, jump, then_label);
-    return;
-}
-
-static void
-pm_compile_if(rb_iseq_t *iseq, const int line, pm_statements_node_t *node_body, pm_node_t *node_else, pm_node_t *predicate, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, pm_compile_context_t *compile_context) {
-    NODE dummy_line_node = generate_dummy_line_node(line, line);
-
-    DECL_ANCHOR(cond_seq);
-
-    LABEL *then_label, *else_label, *end_label;
-
-    INIT_ANCHOR(cond_seq);
-    then_label = NEW_LABEL(line);
-    else_label = NEW_LABEL(line);
-    end_label = 0;
-
-    pm_compile_branch_condition(iseq, cond_seq, predicate, then_label, else_label, src, popped, compile_context);
-    ADD_SEQ(ret, cond_seq);
-
-    if (then_label->refcnt) {
-        ADD_LABEL(ret, then_label);
-
-        DECL_ANCHOR(then_seq);
-        INIT_ANCHOR(then_seq);
-        if (node_body) {
-            pm_compile_node(iseq, (pm_node_t *)node_body, then_seq, src, popped, compile_context);
-            PM_POP_IF_POPPED;
-        }
-        else {
-            PM_PUTNIL_UNLESS_POPPED;
-        }
-
-        if (else_label->refcnt) {
-            end_label = NEW_LABEL(line);
-            ADD_INSNL(then_seq, &dummy_line_node, jump, end_label);
-            PM_POP_UNLESS_POPPED;
-        }
-        ADD_SEQ(ret, then_seq);
-    }
-
-    if (else_label->refcnt) {
-        ADD_LABEL(ret, else_label);
-
-        DECL_ANCHOR(else_seq);
-        INIT_ANCHOR(else_seq);
-        if (node_else) {
-            pm_compile_node(iseq, (pm_node_t *)(((pm_else_node_t *)node_else)->statements), else_seq, src, popped, compile_context);
-        }
-        else {
-            PM_PUTNIL_UNLESS_POPPED;
-        }
-
-        ADD_SEQ(ret, else_seq);
-    }
-
-    if (end_label) {
-        ADD_LABEL(ret, end_label);
-    }
-
-    return;
-}
-
-static void
-pm_compile_while(rb_iseq_t *iseq, int lineno, pm_node_flags_t flags, enum pm_node_type type, pm_statements_node_t *statements, pm_node_t *predicate, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, pm_compile_context_t *compile_context)
-{
-    NODE dummy_line_node = generate_dummy_line_node(lineno, lineno);
-
-    LABEL *prev_start_label = ISEQ_COMPILE_DATA(iseq)->start_label;
-    LABEL *prev_end_label = ISEQ_COMPILE_DATA(iseq)->end_label;
-    LABEL *prev_redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label;
-
-    // TODO: Deal with ensures in here
-    LABEL *next_label = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(lineno); /* next  */
-    LABEL *redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label = NEW_LABEL(lineno);  /* redo  */
-    LABEL *break_label = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(lineno);  /* break */
-    LABEL *end_label = NEW_LABEL(lineno);
-    LABEL *adjust_label = NEW_LABEL(lineno);
-
-    LABEL *next_catch_label = NEW_LABEL(lineno);
-    LABEL *tmp_label = NULL;
-
-    // begin; end while true
-    if (flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
-        tmp_label = NEW_LABEL(lineno);
-        ADD_INSNL(ret, &dummy_line_node, jump, tmp_label);
-    }
-    else {
-        // while true; end
-        ADD_INSNL(ret, &dummy_line_node, jump, next_label);
-    }
-
-    ADD_LABEL(ret, adjust_label);
-    ADD_INSN(ret, &dummy_line_node, putnil);
-    ADD_LABEL(ret, next_catch_label);
-    ADD_INSN(ret, &dummy_line_node, pop);
-    ADD_INSNL(ret, &dummy_line_node, jump, next_label);
-    if (tmp_label) ADD_LABEL(ret, tmp_label);
-
-    ADD_LABEL(ret, redo_label);
-    if (statements) {
-        PM_COMPILE_POPPED((pm_node_t *)statements);
-    }
-
-    ADD_LABEL(ret, next_label);
-
-    if (type == PM_WHILE_NODE) {
-        pm_compile_branch_condition(iseq, ret, predicate, redo_label, end_label, src, popped, compile_context);
-    } else if (type == PM_UNTIL_NODE) {
-        pm_compile_branch_condition(iseq, ret, predicate, end_label, redo_label, src, popped, compile_context);
-    }
-
-    ADD_LABEL(ret, end_label);
-    ADD_ADJUST_RESTORE(ret, adjust_label);
-
-    ADD_INSN(ret, &dummy_line_node, putnil);
-
-    ADD_LABEL(ret, break_label);
-
-    PM_POP_IF_POPPED;
-
-    ADD_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label, NULL,
-            break_label);
-    ADD_CATCH_ENTRY(CATCH_TYPE_NEXT, redo_label, break_label, NULL,
-            next_catch_label);
-    ADD_CATCH_ENTRY(CATCH_TYPE_REDO, redo_label, break_label, NULL,
-            ISEQ_COMPILE_DATA(iseq)->redo_label);
-
-    ISEQ_COMPILE_DATA(iseq)->start_label = prev_start_label;
-    ISEQ_COMPILE_DATA(iseq)->end_label = prev_end_label;
-    ISEQ_COMPILE_DATA(iseq)->redo_label = prev_redo_label;
-    return;
-}
-
-static void
-pm_interpolated_node_compile(pm_node_list_t parts, rb_iseq_t *iseq, NODE dummy_line_node, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, pm_compile_context_t *compile_context)
-{
-    size_t parts_size = parts.size;
-
-    if (parts_size > 0) {
-        for (size_t index = 0; index < parts_size; index++) {
-            pm_node_t *part = parts.nodes[index];
-
-            if (PM_NODE_TYPE_P(part, PM_STRING_NODE)) {
-                pm_string_node_t *string_node = (pm_string_node_t *) part;
-                ADD_INSN1(ret, &dummy_line_node, putobject, parse_string(&string_node->unescaped));
-            }
-            else {
-                PM_COMPILE_NOT_POPPED(part);
-                ADD_INSN(ret, &dummy_line_node, dup);
-                ADD_INSN1(ret, &dummy_line_node, objtostring, new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE , NULL, FALSE));
-                ADD_INSN(ret, &dummy_line_node, anytostring);
-            }
-        }
-    }
-    else {
-        ADD_INSN(ret, &dummy_line_node, putnil);
-    }
-}
-static int
-pm_lookup_local_index(rb_iseq_t *iseq, pm_compile_context_t *compile_context, pm_constant_id_t constant_id)
-{
-    st_data_t local_index;
-
-    int num_params = ISEQ_BODY(iseq)->param.size;
-
-    if (!st_lookup(compile_context->index_lookup_table, constant_id, &local_index)) {
-        rb_bug("This local does not exist");
-    }
-
-    return num_params - (int)local_index;
-}
-
-static int
-pm_lookup_local_index_with_depth(rb_iseq_t *iseq, pm_compile_context_t *compile_context, pm_constant_id_t constant_id, uint32_t depth)
-{
-    for(uint32_t i = 0; i < depth; i++) {
-        compile_context = compile_context->previous;
-        iseq = (rb_iseq_t *)ISEQ_BODY(iseq)->parent_iseq;
-    }
-
-    return pm_lookup_local_index(iseq, compile_context, constant_id);
-}
-
-// This returns the CRuby ID which maps to the pm_constant_id_t
-//
-// Constant_ids in prism are indexes of the constants in prism's constant pool.
-// We add a constants mapping on the compile_context which is a mapping from
-// these constant_id indexes to the CRuby IDs that they represent.
-// This helper method allows easy access to those IDs
-static ID
-pm_constant_id_lookup(pm_compile_context_t *compile_context, pm_constant_id_t constant_id)
-{
-    return compile_context->constants[constant_id - 1];
-}
-
-static rb_iseq_t *
-pm_new_child_iseq(rb_iseq_t *iseq, pm_scope_node_t * node, pm_parser_t *parser,
-               VALUE name, const rb_iseq_t *parent, enum rb_iseq_type type, int line_no)
-{
-    debugs("[new_child_iseq]> ---------------------------------------\n");
-    int isolated_depth = ISEQ_COMPILE_DATA(iseq)->isolated_depth;
-    rb_iseq_t * ret_iseq = pm_iseq_new_with_opt(node, parser, name,
-            rb_iseq_path(iseq), rb_iseq_realpath(iseq),
-            line_no, parent,
-            isolated_depth ? isolated_depth + 1 : 0,
-            type, ISEQ_COMPILE_DATA(iseq)->option);
-    debugs("[new_child_iseq]< ---------------------------------------\n");
-    return ret_iseq;
-}
-
-static int
-pm_compile_class_path(LINK_ANCHOR *const ret, rb_iseq_t *iseq, const pm_node_t *constant_path_node, const NODE *line_node, const uint8_t * src, bool popped, pm_compile_context_t *compile_context)
-{
-    if (PM_NODE_TYPE_P(constant_path_node, PM_CONSTANT_PATH_NODE)) {
-        pm_node_t *parent = ((pm_constant_path_node_t *)constant_path_node)->parent;
-        if (parent) {
-            /* Bar::Foo */
-            PM_COMPILE(parent);
-            return VM_DEFINECLASS_FLAG_SCOPED;
-        }
-        else {
-            /* toplevel class ::Foo */
-            ADD_INSN1(ret, line_node, putobject, rb_cObject);
-            return VM_DEFINECLASS_FLAG_SCOPED;
-        }
-    }
-    else {
-        /* class at cbase Foo */
-        ADD_INSN1(ret, line_node, putspecialobject,
-                INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
-        return 0;
-    }
-}
-
-/**
- * In order to properly compile multiple-assignment, some preprocessing needs to
- * be performed in the case of call or constant path targets. This is when they
- * are read, the "parent" of each of these nodes should only be read once (the
- * receiver in the case of a call, the parent constant in the case of a constant
- * path).
- */
-static uint8_t
-pm_compile_multi_write_lhs(rb_iseq_t *iseq, NODE dummy_line_node, const pm_node_t *node, LINK_ANCHOR *const ret, pm_compile_context_t *compile_context, uint8_t pushed, bool nested) {
-    switch (PM_NODE_TYPE(node)) {
-        case PM_MULTI_TARGET_NODE: {
-            pm_multi_target_node_t *cast = (pm_multi_target_node_t *) node;
-            for (size_t index = 0; index < cast->targets.size; index++) {
-                pushed = pm_compile_multi_write_lhs(iseq, dummy_line_node, cast->targets.nodes[index], ret, compile_context, pushed, false);
-            }
-            break;
-        }
-        case PM_CONSTANT_PATH_TARGET_NODE: {
-            pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *)node;
-            if (cast->parent) {
-                ADD_INSN(ret, &dummy_line_node, putnil);
-                pushed = pm_compile_multi_write_lhs(iseq, dummy_line_node, cast->parent, ret, compile_context, pushed, false);
-            } else {
-                ADD_INSN1(ret, &dummy_line_node, putobject, rb_cObject);
-            }
-            break;
-        }
-        case PM_CONSTANT_PATH_NODE: {
-            pm_constant_path_node_t *cast = (pm_constant_path_node_t *) node;
-            if (cast->parent) {
-                pushed = pm_compile_multi_write_lhs(iseq, dummy_line_node, cast->parent, ret, compile_context, pushed, false);
-            } else {
-                ADD_INSN(ret, &dummy_line_node, pop);
-                ADD_INSN1(ret, &dummy_line_node, putobject, rb_cObject);
-            }
-            pushed = pm_compile_multi_write_lhs(iseq, dummy_line_node, cast->child, ret, compile_context, pushed, cast->parent);
-            break;
-        }
-        case PM_CONSTANT_READ_NODE: {
-            pm_constant_read_node_t *cast = (pm_constant_read_node_t *) node;
-            ADD_INSN1(ret, &dummy_line_node, putobject, RBOOL(!nested));
-            ADD_INSN1(ret, &dummy_line_node, getconstant, ID2SYM(pm_constant_id_lookup(compile_context, cast->name)));
-            pushed = pushed + 2;
-            break;
-        }
-        default:
-            break;
-    }
-
-    return pushed;
-}
-
-/*
- * Compiles a prism node into instruction sequences
- *
- * iseq -            The current instruction sequence object (used for locals)
- * node -            The prism node to compile
- * ret -             The linked list of instruction sequences to append instructions onto
- * popped -          True if compiling something with no side effects, so instructions don't
- *                   need to be added
- * compile_context - Stores parser and local information
- */
-static void
-pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, pm_compile_context_t *compile_context)
-{
-    pm_parser_t *parser = compile_context->parser;
-    pm_newline_list_t newline_list = parser->newline_list;
-    int lineno = (int)pm_newline_list_line_column(&newline_list, node->location.start).line;
-    NODE dummy_line_node = generate_dummy_line_node(lineno, lineno);
-
-    switch (PM_NODE_TYPE(node)) {
-      case PM_ALIAS_METHOD_NODE: {
-          pm_alias_method_node_t *alias_node = (pm_alias_method_node_t *) node;
-
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));
-
-          PM_COMPILE_NOT_POPPED(alias_node->new_name);
-          PM_COMPILE_NOT_POPPED(alias_node->old_name);
-
-          ADD_SEND(ret, &dummy_line_node, id_core_set_method_alias, INT2FIX(3));
-
-          PM_POP_IF_POPPED;
-
-          return;
-      }
-      case PM_AND_NODE: {
-          pm_and_node_t *and_node = (pm_and_node_t *) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-          PM_COMPILE_NOT_POPPED(and_node->left);
-          PM_DUP_UNLESS_POPPED;
-          ADD_INSNL(ret, &dummy_line_node, branchunless, end_label);
-
-          PM_POP_UNLESS_POPPED;
-          PM_COMPILE(and_node->right);
-          ADD_LABEL(ret, end_label);
-          return;
-      }
-      case PM_ARGUMENTS_NODE: {
-          pm_arguments_node_t *arguments_node = (pm_arguments_node_t *) node;
-          pm_node_list_t node_list = arguments_node->arguments;
-          for (size_t index = 0; index < node_list.size; index++) {
-              PM_COMPILE(node_list.nodes[index]);
-          }
-          return;
-      }
-      case PM_ARRAY_NODE: {
-          pm_array_node_t *array_node = (pm_array_node_t *) node;
-          pm_node_list_t elements = array_node->elements;
-          if (elements.size == 1 && pm_static_node_literal_p(elements.nodes[0]) && !popped) {
-              VALUE ary = rb_ary_hidden_new(1);
-              rb_ary_push(ary, pm_static_literal_value(elements.nodes[0]));
-              OBJ_FREEZE(ary);
-
-              ADD_INSN1(ret, &dummy_line_node, duparray, ary);
-          }
-          else {
-              for (size_t index = 0; index < elements.size; index++) {
-                  PM_COMPILE(elements.nodes[index]);
-              }
-
-              if (!popped) {
-                  ADD_INSN1(ret, &dummy_line_node, newarray, INT2FIX(elements.size));
-              }
-          }
-
-          return;
-      }
-      case PM_ASSOC_NODE: {
-          pm_assoc_node_t *assoc_node = (pm_assoc_node_t *) node;
-          PM_COMPILE(assoc_node->key);
-          if (assoc_node->value) {
-              PM_COMPILE(assoc_node->value);
-          }
-          return;
-      }
-      case PM_ASSOC_SPLAT_NODE: {
-          pm_assoc_splat_node_t *assoc_splat_node = (pm_assoc_splat_node_t *)node;
-          PM_COMPILE(assoc_splat_node->value);
-
-          // TODO: Not sure this is accurate, look at FLUSH_CHUNK in the compiler
-          ADD_INSN1(ret, &dummy_line_node, newarraykwsplat, INT2FIX(0));
-
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_BACK_REFERENCE_READ_NODE: {
-          if (!popped) {
-              // Since a back reference is `$<char>`, ruby represents the ID as the
-              // an rb_intern on the value after the `$`.
-              char *char_ptr = (char *)(node->location.start) + 1;
-              ID backref_val = INT2FIX(rb_intern2(char_ptr, 1)) << 1 | 1;
-              ADD_INSN2(ret, &dummy_line_node, getspecial, INT2FIX(1), backref_val);
-          }
-          return;
-      }
-      case PM_BEGIN_NODE: {
-          pm_begin_node_t *begin_node = (pm_begin_node_t *) node;
-          if (begin_node->statements) {
-              PM_COMPILE((pm_node_t *)begin_node->statements);
-          }
-          else {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-          }
-          return;
-      }
-      case PM_BLOCK_ARGUMENT_NODE: {
-          pm_block_argument_node_t *block_argument_node = (pm_block_argument_node_t *) node;
-          PM_COMPILE(block_argument_node->expression);
-          return;
-      }
-      case PM_BREAK_NODE: {
-          pm_break_node_t *break_node = (pm_break_node_t *) node;
-          if (break_node->arguments) {
-              PM_COMPILE_NOT_POPPED((pm_node_t *)break_node->arguments);
-          }
-          else {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-          }
-
-          ADD_INSNL(ret, &dummy_line_node, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
-
-          return;
-      }
-      case PM_CALL_NODE: {
-          pm_call_node_t *call_node = (pm_call_node_t *) node;
-
-          ID method_id = parse_string_symbol(&call_node->name);
-          int flags = 0;
-          int orig_argc = 0;
-
-          if (call_node->receiver == NULL) {
-              ADD_INSN(ret, &dummy_line_node, putself);
-          } else {
-              PM_COMPILE_NOT_POPPED(call_node->receiver);
-          }
-
-          if (call_node->arguments == NULL) {
-              if (flags & VM_CALL_FCALL) {
-                  flags |= VM_CALL_VCALL;
-              }
-          } else {
-              pm_arguments_node_t *arguments = call_node->arguments;
-              PM_COMPILE_NOT_POPPED((pm_node_t *) arguments);
-              orig_argc = (int)arguments->arguments.size;
-          }
-
-          VALUE block_iseq = Qnil;
-          if (call_node->block != NULL && PM_NODE_TYPE_P(call_node->block, PM_BLOCK_NODE)) {
-              // Scope associated with the block
-              pm_scope_node_t scope_node;
-              pm_scope_node_init(call_node->block, &scope_node);
-
-              const rb_iseq_t *block_iseq = NEW_CHILD_ISEQ(&scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno);
-              ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
-              ADD_SEND_WITH_BLOCK(ret, &dummy_line_node, method_id, INT2FIX(orig_argc), block_iseq);
-          }
-          else {
-              if (node->flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
-                  flags |= VM_CALL_VCALL;
-              }
-
-              if (call_node->block != NULL) {
-                  PM_COMPILE_NOT_POPPED(call_node->block);
-                  flags |= VM_CALL_ARGS_BLOCKARG;
-              }
-
-              if (block_iseq == Qnil && flags == 0) {
-                  flags |= VM_CALL_ARGS_SIMPLE;
-              }
-
-              if (call_node->receiver == NULL) {
-                  flags |= VM_CALL_FCALL;
-              }
-
-              ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(orig_argc), INT2FIX(flags));
-          }
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_CLASS_NODE: {
-          pm_class_node_t *class_node = (pm_class_node_t *)node;
-          pm_scope_node_t scope_node;
-          pm_scope_node_init((pm_node_t *)class_node, &scope_node);
-
-          ID class_id = pm_constant_id_lookup(compile_context, class_node->name);
-
-          VALUE class_name = rb_str_freeze(rb_sprintf("<class:%"PRIsVALUE">", rb_id2str(class_id)));
-
-          const rb_iseq_t *class_iseq = NEW_CHILD_ISEQ(&scope_node, class_name, ISEQ_TYPE_CLASS, lineno);
-
-          // TODO: Once we merge constant path nodes correctly, fix this flag
-          const int flags = VM_DEFINECLASS_TYPE_CLASS |
-              (class_node->superclass ? VM_DEFINECLASS_FLAG_HAS_SUPERCLASS : 0) |
-              pm_compile_class_path(ret, iseq, class_node->constant_path, &dummy_line_node, src, false, compile_context);
-
-          if (class_node->superclass) {
-              PM_COMPILE(class_node->superclass);
-          }
-          else {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-          }
-
-          ADD_INSN3(ret, &dummy_line_node, defineclass, ID2SYM(class_id), class_iseq, INT2FIX(flags));
-          RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)class_iseq);
-
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
-          pm_class_variable_and_write_node_t *class_variable_and_write_node = (pm_class_variable_and_write_node_t*) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          ID class_variable_name_id = pm_constant_id_lookup(compile_context, class_variable_and_write_node->name);
-          VALUE class_variable_name_val = ID2SYM(class_variable_name_id);
-
-          ADD_INSN2(ret, &dummy_line_node, getclassvariable,
-                  class_variable_name_val,
-                  get_cvar_ic_value(iseq, class_variable_name_id));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchunless, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          PM_COMPILE_NOT_POPPED(class_variable_and_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN2(ret, &dummy_line_node, setclassvariable,
-                  class_variable_name_val,
-                  get_cvar_ic_value(iseq, class_variable_name_id));
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
-          pm_class_variable_operator_write_node_t *class_variable_operator_write_node = (pm_class_variable_operator_write_node_t*) node;
-
-          ID class_variable_name_id = pm_constant_id_lookup(compile_context, class_variable_operator_write_node->name);
-          VALUE class_variable_name_val = ID2SYM(class_variable_name_id);
-
-          ADD_INSN2(ret, &dummy_line_node, getclassvariable,
-                  class_variable_name_val,
-                  get_cvar_ic_value(iseq, class_variable_name_id));
-
-          PM_COMPILE_NOT_POPPED(class_variable_operator_write_node->value);
-          ID method_id = pm_constant_id_lookup(compile_context, class_variable_operator_write_node->operator);
-
-          int flags = VM_CALL_ARGS_SIMPLE;
-          ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN2(ret, &dummy_line_node, setclassvariable,
-                  class_variable_name_val,
-                  get_cvar_ic_value(iseq, class_variable_name_id));
-
-          return;
-      }
-      case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
-          pm_class_variable_or_write_node_t *class_variable_or_write_node = (pm_class_variable_or_write_node_t*) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          ID class_variable_name_id = pm_constant_id_lookup(compile_context, class_variable_or_write_node->name);
-          VALUE class_variable_name_val = ID2SYM(class_variable_name_id);
-
-          ADD_INSN2(ret, &dummy_line_node, getclassvariable,
-                  class_variable_name_val,
-                  get_cvar_ic_value(iseq, class_variable_name_id));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchif, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          PM_COMPILE_NOT_POPPED(class_variable_or_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN2(ret, &dummy_line_node, setclassvariable,
-                  class_variable_name_val,
-                  get_cvar_ic_value(iseq, class_variable_name_id));
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_CLASS_VARIABLE_READ_NODE: {
-          if (!popped) {
-              pm_class_variable_read_node_t *class_variable_read_node = (pm_class_variable_read_node_t *) node;
-              ID cvar_name = pm_constant_id_lookup(compile_context, class_variable_read_node->name);
-              ADD_INSN2(
-                      ret,
-                      &dummy_line_node,
-                      getclassvariable,
-                      ID2SYM(cvar_name),
-                      get_cvar_ic_value(iseq, cvar_name)
-                      );
-          }
-          return;
-      }
-      case PM_CLASS_VARIABLE_TARGET_NODE: {
-          pm_class_variable_target_node_t *write_node = (pm_class_variable_target_node_t *) node;
-          ID cvar_name = pm_constant_id_lookup(compile_context, write_node->name);
-          ADD_INSN2(ret, &dummy_line_node, setclassvariable, ID2SYM(cvar_name), get_cvar_ic_value(iseq, cvar_name));
-          return;
-      }
-      case PM_CLASS_VARIABLE_WRITE_NODE: {
-          pm_class_variable_write_node_t *write_node = (pm_class_variable_write_node_t *) node;
-          PM_COMPILE_NOT_POPPED(write_node->value);
-          PM_DUP_UNLESS_POPPED;
-
-          ID cvar_name = pm_constant_id_lookup(compile_context, write_node->name);
-          ADD_INSN2(ret, &dummy_line_node, setclassvariable, ID2SYM(cvar_name), get_cvar_ic_value(iseq, cvar_name));
-          return;
-      }
-      case PM_CONSTANT_PATH_NODE: {
-          pm_constant_path_node_t *constant_path_node = (pm_constant_path_node_t*) node;
-          if (constant_path_node->parent) {
-              PM_COMPILE_NOT_POPPED(constant_path_node->parent);
-          }
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qfalse);
-
-          assert(PM_NODE_TYPE_P(constant_path_node->child, PM_CONSTANT_READ_NODE));
-          pm_constant_read_node_t *child = (pm_constant_read_node_t *) constant_path_node->child;
-
-          ADD_INSN1(ret, &dummy_line_node, getconstant, ID2SYM(pm_constant_id_lookup(compile_context, child->name)));
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_CONSTANT_PATH_TARGET_NODE: {
-          pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *)node;
-
-          PM_COMPILE(cast->parent);
-
-          return;
-      }
-      case PM_CONSTANT_PATH_WRITE_NODE: {
-          pm_constant_path_write_node_t *constant_path_write_node = (pm_constant_path_write_node_t*) node;
-          PM_COMPILE(constant_path_write_node->value);
-          PM_DUP_UNLESS_POPPED;
-
-          ID constant_var_name = parse_location_symbol(&constant_path_write_node->target->base.location);
-
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
-          ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(constant_var_name));
-          return;
-      }
-      case PM_CONSTANT_READ_NODE: {
-          pm_constant_read_node_t *constant_read_node = (pm_constant_read_node_t *) node;
-          ADD_INSN(ret, &dummy_line_node, putnil);
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue);
-          ADD_INSN1(ret, &dummy_line_node, getconstant, ID2SYM(pm_constant_id_lookup(compile_context, constant_read_node->name)));
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_CONSTANT_AND_WRITE_NODE: {
-          pm_constant_and_write_node_t *constant_and_write_node = (pm_constant_and_write_node_t*) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          VALUE constant_name = ID2SYM(pm_constant_id_lookup(compile_context, constant_and_write_node->name));
-
-          ADD_INSN(ret, &dummy_line_node, putnil);
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue);
-          ADD_INSN1(ret, &dummy_line_node, getconstant, constant_name);
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchunless, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          PM_COMPILE_NOT_POPPED(constant_and_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
-          ADD_INSN1(ret, &dummy_line_node, setconstant, constant_name);
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_CONSTANT_OPERATOR_WRITE_NODE: {
-          pm_constant_operator_write_node_t *constant_operator_write_node = (pm_constant_operator_write_node_t*) node;
-
-          ID constant_name = pm_constant_id_lookup(compile_context, constant_operator_write_node->name);
-          ADD_INSN(ret, &dummy_line_node, putnil);
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue);
-          ADD_INSN1(ret, &dummy_line_node, getconstant, ID2SYM(constant_name));
-
-          PM_COMPILE_NOT_POPPED(constant_operator_write_node->value);
-          ID method_id = pm_constant_id_lookup(compile_context, constant_operator_write_node->operator);
-
-          int flags = VM_CALL_ARGS_SIMPLE;
-          ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
-          ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(constant_name));
-
-          return;
-      }
-      case PM_CONSTANT_OR_WRITE_NODE: {
-          pm_constant_or_write_node_t *constant_or_write_node = (pm_constant_or_write_node_t*) node;
-
-          LABEL *set_label= NEW_LABEL(lineno);
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          ADD_INSN(ret, &dummy_line_node, putnil);
-          VALUE constant_name = ID2SYM(pm_constant_id_lookup(compile_context, constant_or_write_node->name));
-
-          ADD_INSN3(ret, &dummy_line_node, defined, INT2FIX(DEFINED_CONST), constant_name, Qtrue);
-
-          ADD_INSNL(ret, &dummy_line_node, branchunless, set_label);
-
-          ADD_INSN(ret, &dummy_line_node, putnil);
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue);
-          ADD_INSN1(ret, &dummy_line_node, getconstant, constant_name);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchif, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          ADD_LABEL(ret, set_label);
-          PM_COMPILE_NOT_POPPED(constant_or_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
-          ADD_INSN1(ret, &dummy_line_node, setconstant, constant_name);
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_CONSTANT_TARGET_NODE: {
-          pm_constant_target_node_t *constant_write_node = (pm_constant_target_node_t *) node;
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
-          ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(pm_constant_id_lookup(compile_context, constant_write_node->name)));
-          return;
-      }
-      case PM_CONSTANT_WRITE_NODE: {
-          pm_constant_write_node_t *constant_write_node = (pm_constant_write_node_t *) node;
-          PM_COMPILE_NOT_POPPED(constant_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
-          ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(pm_constant_id_lookup(compile_context, constant_write_node->name)));
-          return;
-      }
-      case PM_DEF_NODE: {
-          pm_def_node_t *def_node = (pm_def_node_t *) node;
-          ID method_name = pm_constant_id_lookup(compile_context, def_node->name);
-          pm_scope_node_t scope_node;
-          pm_scope_node_init((pm_node_t *)def_node, &scope_node);
-          rb_iseq_t *method_iseq = NEW_ISEQ(&scope_node, rb_id2str(method_name), ISEQ_TYPE_METHOD, lineno);
-
-          ADD_INSN2(ret, &dummy_line_node, definemethod, ID2SYM(method_name), method_iseq);
-          RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)method_iseq);
-
-          if (!popped) {
-              ADD_INSN1(ret, &dummy_line_node, putobject, ID2SYM(method_name));
-          }
-          return;
-      }
-      case PM_DEFINED_NODE: {
-          ADD_INSN(ret, &dummy_line_node, putself);
-          pm_defined_node_t *defined_node = (pm_defined_node_t *)node;
-          // TODO: Correct defined_type
-          enum defined_type dtype = DEFINED_CONST;
-
-          VALUE sym = Qnil;
-          if (PM_NODE_TYPE_P(defined_node->value, PM_INTEGER_NODE)) {
-              sym = parse_integer((pm_integer_node_t *) defined_node->value);
-          }
-
-          ADD_INSN3(ret, &dummy_line_node, defined, INT2FIX(dtype), sym, rb_iseq_defined_string(dtype));
-          return;
-      }
-      case PM_EMBEDDED_STATEMENTS_NODE: {
-          pm_embedded_statements_node_t *embedded_statements_node = (pm_embedded_statements_node_t *)node;
-
-          if (embedded_statements_node->statements) {
-              PM_COMPILE((pm_node_t *) (embedded_statements_node->statements));
-          }
-          else {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-          }
-
-          PM_POP_IF_POPPED;
-          // TODO: Concatenate the strings that exist here
-          return;
-      }
-      case PM_EMBEDDED_VARIABLE_NODE: {
-          pm_embedded_variable_node_t *embedded_node = (pm_embedded_variable_node_t *)node;
-          PM_COMPILE(embedded_node->variable);
-          return;
-      }
-      case PM_FALSE_NODE:
-        if (!popped) {
-            ADD_INSN1(ret, &dummy_line_node, putobject, Qfalse);
-        }
-        return;
-      case PM_FLIP_FLOP_NODE: {
-          // TODO: The labels here are wrong, figure out why.....
-          pm_flip_flop_node_t *flip_flop_node = (pm_flip_flop_node_t *)node;
-
-          LABEL *lend = NEW_LABEL(lineno);
-          LABEL *then_label = NEW_LABEL(lineno);
-          LABEL *else_label = NEW_LABEL(lineno);
-          //TODO:         int again = type == NODE_FLIP2;
-          int again = 0;
-
-          rb_num_t cnt = ISEQ_FLIP_CNT_INCREMENT(ISEQ_BODY(iseq)->local_iseq)
-              + VM_SVAR_FLIPFLOP_START;
-          VALUE key = INT2FIX(cnt);
-
-          ADD_INSN2(ret, &dummy_line_node, getspecial, key, INT2FIX(0));
-          ADD_INSNL(ret, &dummy_line_node, branchif, lend);
-
-          PM_COMPILE(flip_flop_node->left);
-          /* *flip == 0 */
-          ADD_INSNL(ret, &dummy_line_node, branchunless, else_label);
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue);
-          ADD_INSN1(ret, &dummy_line_node, setspecial, key);
-          if (!again) {
-              ADD_INSNL(ret, &dummy_line_node, jump, then_label);
-          }
-
-          /* *flip == 1 */
-          ADD_LABEL(ret, lend);
-          PM_COMPILE(flip_flop_node->right);
-          ADD_INSNL(ret, &dummy_line_node, branchunless, then_label);
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qfalse);
-          ADD_INSN1(ret, &dummy_line_node, setspecial, key);
-          ADD_INSNL(ret, &dummy_line_node, jump, then_label);
-          ADD_LABEL(ret, then_label);
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue);
-          ADD_INSNL(ret, &dummy_line_node, jump, lend);
-          ADD_LABEL(ret, else_label);
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qfalse);
-          ADD_LABEL(ret, lend);
-          return;
-      }
-      case PM_FLOAT_NODE: {
-          if (!popped) {
-              ADD_INSN1(ret, &dummy_line_node, putobject, parse_float(node));
-          }
-          return;
-      }
-      case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
-          pm_global_variable_and_write_node_t *global_variable_and_write_node = (pm_global_variable_and_write_node_t*) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          VALUE global_variable_name = ID2SYM(pm_constant_id_lookup(compile_context, global_variable_and_write_node->name));
-
-          ADD_INSN1(ret, &dummy_line_node, getglobal, global_variable_name);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchunless, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          PM_COMPILE_NOT_POPPED(global_variable_and_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN1(ret, &dummy_line_node, setglobal, global_variable_name);
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
-          pm_global_variable_operator_write_node_t *global_variable_operator_write_node = (pm_global_variable_operator_write_node_t*) node;
-
-          VALUE global_variable_name = ID2SYM(pm_constant_id_lookup(compile_context, global_variable_operator_write_node->name));
-          ADD_INSN1(ret, &dummy_line_node, getglobal, global_variable_name);
-
-          PM_COMPILE_NOT_POPPED(global_variable_operator_write_node->value);
-          ID method_id = pm_constant_id_lookup(compile_context, global_variable_operator_write_node->operator);
-
-          int flags = VM_CALL_ARGS_SIMPLE;
-          ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN1(ret, &dummy_line_node, setglobal, global_variable_name);
-
-          return;
-      }
-      case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
-          pm_global_variable_or_write_node_t *global_variable_or_write_node = (pm_global_variable_or_write_node_t*) node;
-
-          LABEL *set_label= NEW_LABEL(lineno);
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          ADD_INSN(ret, &dummy_line_node, putnil);
-          VALUE global_variable_name = ID2SYM(pm_constant_id_lookup(compile_context, global_variable_or_write_node->name));
-
-          ADD_INSN3(ret, &dummy_line_node, defined, INT2FIX(DEFINED_GVAR), global_variable_name, Qtrue);
-
-          ADD_INSNL(ret, &dummy_line_node, branchunless, set_label);
-
-          ADD_INSN1(ret, &dummy_line_node, getglobal, global_variable_name);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchif, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          ADD_LABEL(ret, set_label);
-          PM_COMPILE_NOT_POPPED(global_variable_or_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN1(ret, &dummy_line_node, setglobal, global_variable_name);
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_GLOBAL_VARIABLE_READ_NODE: {
-          pm_global_variable_read_node_t *global_variable_read_node = (pm_global_variable_read_node_t *)node;
-          VALUE global_variable_name = ID2SYM(pm_constant_id_lookup(compile_context, global_variable_read_node->name));
-          ADD_INSN1(ret, &dummy_line_node, getglobal, global_variable_name);
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_GLOBAL_VARIABLE_TARGET_NODE: {
-          pm_global_variable_target_node_t *write_node = (pm_global_variable_target_node_t *) node;
-
-          ID ivar_name = pm_constant_id_lookup(compile_context, write_node->name);
-          ADD_INSN1(ret, &dummy_line_node, setglobal, ID2SYM(ivar_name));
-          return;
-      }
-      case PM_GLOBAL_VARIABLE_WRITE_NODE: {
-          pm_global_variable_write_node_t *write_node = (pm_global_variable_write_node_t *) node;
-          PM_COMPILE_NOT_POPPED(write_node->value);
-          PM_DUP_UNLESS_POPPED;
-          ID ivar_name = pm_constant_id_lookup(compile_context, write_node->name);
-          ADD_INSN1(ret, &dummy_line_node, setglobal, ID2SYM(ivar_name));
-          return;
-      }
-      case PM_HASH_NODE: {
-          pm_hash_node_t *hash_node = (pm_hash_node_t *) node;
-          pm_node_list_t elements = hash_node->elements;
-
-          if (elements.size == 1) {
-              assert(PM_NODE_TYPE_P(elements.nodes[0], PM_ASSOC_NODE));
-              pm_assoc_node_t *assoc_node = (pm_assoc_node_t *) elements.nodes[0];
-
-              if (pm_static_node_literal_p(assoc_node->key) &&
-                      pm_static_node_literal_p(assoc_node->value)) {
-                  VALUE hash = rb_hash_new_with_size(1);
-                  hash = rb_obj_hide(hash);
-                  OBJ_FREEZE(hash);
-                  ADD_INSN1(ret, &dummy_line_node, duphash, hash);
-                  return;
-              }
-          }
-
-          for (size_t index = 0; index < elements.size; index++) {
-              PM_COMPILE(elements.nodes[index]);
-          }
-
-          if (!popped) {
-              ADD_INSN1(ret, &dummy_line_node, newhash, INT2FIX(elements.size * 2));
-          }
-          return;
-      }
-      case PM_IF_NODE: {
-          const int line = (int)pm_newline_list_line_column(&(parser->newline_list), node->location.start).line;
-          pm_if_node_t *if_node = (pm_if_node_t *)node;
-          pm_statements_node_t *node_body = if_node->statements;
-          pm_node_t *node_else = if_node->consequent;
-          pm_node_t *predicate = if_node->predicate;
-
-          pm_compile_if(iseq, line, node_body, node_else, predicate, ret, src, popped, compile_context);
-          return;
-      }
-      case PM_IMAGINARY_NODE: {
-          if (!popped) {
-              ADD_INSN1(ret, &dummy_line_node, putobject, parse_imaginary((pm_imaginary_node_t *)node));
-          }
-          return;
-      }
-      case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
-          pm_instance_variable_and_write_node_t *instance_variable_and_write_node = (pm_instance_variable_and_write_node_t*) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          ID instance_variable_name_id = pm_constant_id_lookup(compile_context, instance_variable_and_write_node->name);
-
-          VALUE instance_variable_name_val = ID2SYM(instance_variable_name_id);
-
-          ADD_INSN2(ret, &dummy_line_node, getinstancevariable,
-                  instance_variable_name_val,
-                  get_ivar_ic_value(iseq, instance_variable_name_id));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchunless, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          PM_COMPILE_NOT_POPPED(instance_variable_and_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN2(ret, &dummy_line_node, setinstancevariable,
-                  instance_variable_name_val,
-                  get_ivar_ic_value(iseq, instance_variable_name_id));
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
-          pm_instance_variable_operator_write_node_t *instance_variable_operator_write_node = (pm_instance_variable_operator_write_node_t*) node;
-
-          ID instance_variable_name_id = pm_constant_id_lookup(compile_context, instance_variable_operator_write_node->name);
-          VALUE instance_variable_name_val = ID2SYM(instance_variable_name_id);
-
-          ADD_INSN2(ret, &dummy_line_node, getinstancevariable,
-                  instance_variable_name_val,
-                  get_ivar_ic_value(iseq, instance_variable_name_id));
-
-          PM_COMPILE_NOT_POPPED(instance_variable_operator_write_node->value);
-          ID method_id = pm_constant_id_lookup(compile_context, instance_variable_operator_write_node->operator);
-
-          int flags = VM_CALL_ARGS_SIMPLE;
-          ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN2(ret, &dummy_line_node, setinstancevariable,
-                  instance_variable_name_val,
-                  get_ivar_ic_value(iseq, instance_variable_name_id));
-
-          return;
-      }
-      case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
-          pm_instance_variable_or_write_node_t *instance_variable_or_write_node = (pm_instance_variable_or_write_node_t*) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          ID instance_variable_name_id = pm_constant_id_lookup(compile_context, instance_variable_or_write_node->name);
-          VALUE instance_variable_name_val = ID2SYM(instance_variable_name_id);
-
-          ADD_INSN2(ret, &dummy_line_node, getinstancevariable,
-                  instance_variable_name_val,
-                  get_ivar_ic_value(iseq, instance_variable_name_id));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchif, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          PM_COMPILE_NOT_POPPED(instance_variable_or_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSN2(ret, &dummy_line_node, setinstancevariable,
-                  instance_variable_name_val,
-                  get_ivar_ic_value(iseq, instance_variable_name_id));
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_INSTANCE_VARIABLE_READ_NODE: {
-          if (!popped) {
-              pm_instance_variable_read_node_t *instance_variable_read_node = (pm_instance_variable_read_node_t *) node;
-              ID ivar_name = pm_constant_id_lookup(compile_context, instance_variable_read_node->name);
-              ADD_INSN2(ret, &dummy_line_node, getinstancevariable,
-                      ID2SYM(ivar_name),
-                      get_ivar_ic_value(iseq, ivar_name));
-          }
-          return;
-      }
-      case PM_INSTANCE_VARIABLE_TARGET_NODE: {
-          pm_instance_variable_target_node_t *write_node = (pm_instance_variable_target_node_t *) node;
-
-          ID ivar_name = pm_constant_id_lookup(compile_context, write_node->name);
-          ADD_INSN2(ret, &dummy_line_node, setinstancevariable,
-                  ID2SYM(ivar_name),
-                  get_ivar_ic_value(iseq, ivar_name));
-          return;
-      }
-      case PM_INSTANCE_VARIABLE_WRITE_NODE: {
-          pm_instance_variable_write_node_t *write_node = (pm_instance_variable_write_node_t *) node;
-          PM_COMPILE_NOT_POPPED(write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ID ivar_name = pm_constant_id_lookup(compile_context, write_node->name);
-          ADD_INSN2(ret, &dummy_line_node, setinstancevariable,
-                  ID2SYM(ivar_name),
-                  get_ivar_ic_value(iseq, ivar_name));
-          return;
-      }
-      case PM_INTEGER_NODE: {
-          if (!popped) {
-              ADD_INSN1(ret, &dummy_line_node, putobject, parse_integer((pm_integer_node_t *) node));
-          }
-          return;
-      }
-      case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
-          pm_interpolated_regular_expression_node_t *interp_regular_expression_node= (pm_interpolated_regular_expression_node_t *) node;
-          pm_interpolated_node_compile(interp_regular_expression_node->parts, iseq, dummy_line_node, ret, src, popped, compile_context);
-          if (interp_regular_expression_node->parts.size > 1) {
-              ADD_INSN2(ret, &dummy_line_node, toregexp, INT2FIX(0), INT2FIX((int)(interp_regular_expression_node->parts.size)));
-          }
-
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_INTERPOLATED_STRING_NODE: {
-          pm_interpolated_string_node_t *interp_string_node = (pm_interpolated_string_node_t *) node;
-          pm_interpolated_node_compile(interp_string_node->parts, iseq, dummy_line_node, ret, src, popped, compile_context);
-
-          size_t parts_size = interp_string_node->parts.size;
-          if (parts_size > 1) {
-              ADD_INSN1(ret, &dummy_line_node, concatstrings, INT2FIX((int)(parts_size)));
-          }
-
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_INTERPOLATED_SYMBOL_NODE: {
-          pm_interpolated_symbol_node_t *interp_symbol_node = (pm_interpolated_symbol_node_t *) node;
-          pm_interpolated_node_compile(interp_symbol_node->parts, iseq, dummy_line_node, ret, src, popped, compile_context);
-
-          size_t parts_size = interp_symbol_node->parts.size;
-          if (parts_size > 1) {
-              ADD_INSN1(ret, &dummy_line_node, concatstrings, INT2FIX((int)(parts_size)));
-          }
-
-          if (!popped) {
-              ADD_INSN(ret, &dummy_line_node, intern);
-          }
-          else {
-              ADD_INSN(ret, &dummy_line_node, pop);
-          }
-
-          return;
-      }
-      case PM_INTERPOLATED_X_STRING_NODE: {
-          pm_interpolated_x_string_node_t *interp_x_string_node = (pm_interpolated_x_string_node_t *) node;
-          ADD_INSN(ret, &dummy_line_node, putself);
-          pm_interpolated_node_compile(interp_x_string_node->parts, iseq, dummy_line_node, ret, src, false, compile_context);
-
-          size_t parts_size = interp_x_string_node->parts.size;
-          if (parts_size > 1) {
-              ADD_INSN1(ret, &dummy_line_node, concatstrings, INT2FIX((int)(parts_size)));
-          }
-
-          ADD_SEND_WITH_FLAG(ret, &dummy_line_node, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_KEYWORD_HASH_NODE: {
-          pm_keyword_hash_node_t *keyword_hash_node = (pm_keyword_hash_node_t *) node;
-          pm_node_list_t elements = keyword_hash_node->elements;
-
-          for (size_t index = 0; index < elements.size; index++) {
-              PM_COMPILE(elements.nodes[index]);
-          }
-
-          ADD_INSN1(ret, &dummy_line_node, newhash, INT2FIX(elements.size * 2));
-          return;
-      }
-      case PM_LAMBDA_NODE: {
-          pm_scope_node_t scope_node;
-          pm_scope_node_init((pm_node_t *)node, &scope_node);
-
-          const rb_iseq_t *block = NEW_CHILD_ISEQ(&scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno);
-          VALUE argc = INT2FIX(0);
-
-          ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
-          ADD_CALL_WITH_BLOCK(ret, &dummy_line_node, idLambda, argc, block);
-          RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)block);
-
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
-          pm_local_variable_and_write_node_t *local_variable_and_write_node = (pm_local_variable_and_write_node_t*) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          pm_constant_id_t constant_id = local_variable_and_write_node->name;
-          int depth = local_variable_and_write_node->depth;
-          int local_index = pm_lookup_local_index_with_depth(iseq, compile_context, constant_id, depth);
-          ADD_GETLOCAL(ret, &dummy_line_node, local_index, depth);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchunless, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          PM_COMPILE_NOT_POPPED(local_variable_and_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_SETLOCAL(ret, &dummy_line_node, local_index, depth);
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
-          pm_local_variable_operator_write_node_t *local_variable_operator_write_node = (pm_local_variable_operator_write_node_t*) node;
-
-          pm_constant_id_t constant_id = local_variable_operator_write_node->name;
-
-          int depth = local_variable_operator_write_node->depth;
-          int local_index = pm_lookup_local_index_with_depth(iseq, compile_context, constant_id, depth);
-          ADD_GETLOCAL(ret, &dummy_line_node, local_index, depth);
-
-          PM_COMPILE_NOT_POPPED(local_variable_operator_write_node->value);
-          ID method_id = pm_constant_id_lookup(compile_context, local_variable_operator_write_node->operator);
-
-          int flags = VM_CALL_ARGS_SIMPLE | VM_CALL_FCALL | VM_CALL_VCALL;
-          ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags));
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_SETLOCAL(ret, &dummy_line_node, local_index, depth);
-
-          return;
-      }
-      case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
-          pm_local_variable_or_write_node_t *local_variable_or_write_node = (pm_local_variable_or_write_node_t*) node;
-
-          LABEL *set_label= NEW_LABEL(lineno);
-          LABEL *end_label = NEW_LABEL(lineno);
-
-          ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue);
-          ADD_INSNL(ret, &dummy_line_node, branchunless, set_label);
-
-          pm_constant_id_t constant_id = local_variable_or_write_node->name;
-          int depth = local_variable_or_write_node->depth;
-          int local_index = pm_lookup_local_index_with_depth(iseq, compile_context, constant_id, depth);
-          ADD_GETLOCAL(ret, &dummy_line_node, local_index, depth);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_INSNL(ret, &dummy_line_node, branchif, end_label);
-
-          PM_POP_UNLESS_POPPED;
-
-          ADD_LABEL(ret, set_label);
-          PM_COMPILE_NOT_POPPED(local_variable_or_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          ADD_SETLOCAL(ret, &dummy_line_node, local_index, depth);
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_LOCAL_VARIABLE_READ_NODE: {
-          pm_local_variable_read_node_t *local_read_node = (pm_local_variable_read_node_t *) node;
-
-          if (!popped) {
-              int index = pm_lookup_local_index(iseq, compile_context, local_read_node->name);
-              ADD_GETLOCAL(ret, &dummy_line_node, index, local_read_node->depth);
-          }
-          return;
-      }
-      case PM_LOCAL_VARIABLE_TARGET_NODE: {
-          pm_local_variable_target_node_t *local_write_node = (pm_local_variable_target_node_t *) node;
-
-          pm_constant_id_t constant_id = local_write_node->name;
-          int index = pm_lookup_local_index(iseq, compile_context, constant_id);
-
-          ADD_SETLOCAL(ret, &dummy_line_node, (int)index, local_write_node->depth);
-          return;
-      }
-      case PM_LOCAL_VARIABLE_WRITE_NODE: {
-          pm_local_variable_write_node_t *local_write_node = (pm_local_variable_write_node_t *) node;
-          PM_COMPILE_NOT_POPPED(local_write_node->value);
-
-          PM_DUP_UNLESS_POPPED;
-
-          pm_constant_id_t constant_id = local_write_node->name;
-          int index = pm_lookup_local_index(iseq, compile_context, constant_id);
-
-          ADD_SETLOCAL(ret, &dummy_line_node, (int)index, local_write_node->depth);
-          return;
-      }
-      case PM_MATCH_LAST_LINE_NODE: {
-          if (!popped) {
-              pm_match_last_line_node_t *regular_expression_node = (pm_match_last_line_node_t *) node;
-              VALUE regex_str = parse_string(&regular_expression_node->unescaped);
-              int flags = 0;
-
-              if (regular_expression_node->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
-                  flags |= ONIG_OPTION_IGNORECASE;
-              }
-
-              if (regular_expression_node->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
-                  flags |= ONIG_OPTION_MULTILINE;
-              }
-
-              if (regular_expression_node->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
-                  flags |= ONIG_OPTION_EXTEND;
-              }
-
-              VALUE regex = rb_reg_new(RSTRING_PTR(regex_str), RSTRING_LEN(regex_str), flags);
-              ADD_INSN1(ret, &dummy_line_node, putobject, regex);
-              ADD_INSN2(ret, &dummy_line_node, getspecial, INT2FIX(0), INT2FIX(0));
-              ADD_SEND(ret, &dummy_line_node, idEqTilde, INT2NUM(1));
-          }
-
-          return;
-      }
-      case PM_MISSING_NODE: {
-          rb_bug("A pm_missing_node_t should not exist in prism's AST.");
-          return;
-      }
-      case PM_MODULE_NODE: {
-          pm_module_node_t *module_node = (pm_module_node_t *)node;
-          pm_scope_node_t scope_node;
-          pm_scope_node_init((pm_node_t *)module_node, &scope_node);
-
-          ID module_id = pm_constant_id_lookup(compile_context, module_node->name);
-          VALUE module_name = rb_str_freeze(rb_sprintf("<module:%"PRIsVALUE">", rb_id2str(module_id)));
-
-          const rb_iseq_t *module_iseq = NEW_CHILD_ISEQ(&scope_node, module_name, ISEQ_TYPE_CLASS, lineno);
-
-          const int flags = VM_DEFINECLASS_TYPE_MODULE |
-              pm_compile_class_path(ret, iseq, module_node->constant_path, &dummy_line_node, src, popped, compile_context);
-
-          ADD_INSN(ret, &dummy_line_node, putnil);
-          ADD_INSN3(ret, &dummy_line_node, defineclass, ID2SYM(module_id), module_iseq, INT2FIX(flags));
-          RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)module_iseq);
-
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_MULTI_TARGET_NODE: {
-          pm_multi_target_node_t *cast = (pm_multi_target_node_t *) node;
-          for (size_t index = 0; index < cast->targets.size; index++) {
-              PM_COMPILE(cast->targets.nodes[index]);
-          }
-          return;
-      }
-      case PM_MULTI_WRITE_NODE: {
-          pm_multi_write_node_t *multi_write_node = (pm_multi_write_node_t *)node;
-          pm_node_list_t node_list = multi_write_node->targets;
-
-          // pre-process the left hand side of multi-assignments.
-          uint8_t pushed = 0;
-          for (size_t index = 0; index < node_list.size; index++) {
-              pushed = pm_compile_multi_write_lhs(iseq, dummy_line_node, node_list.nodes[index], ret, compile_context, pushed, false);
-          }
-
-          PM_COMPILE_NOT_POPPED(multi_write_node->value);
-
-          // TODO: int flag = 0x02 | (NODE_NAMED_REST_P(restn) ? 0x01 : 0x00);
-          int flag = 0x00;
-
-          if (!popped) {
-              ADD_INSN(ret, &dummy_line_node, dup);
-          }
-          ADD_INSN2(ret, &dummy_line_node, expandarray, INT2FIX(multi_write_node->targets.size), INT2FIX(flag));
-
-          for (size_t index = 0; index < node_list.size; index++) {
-              pm_node_t *considered_node = node_list.nodes[index];
-
-              if (PM_NODE_TYPE_P(considered_node, PM_CONSTANT_PATH_TARGET_NODE) && pushed > 0) {
-                  pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *)considered_node;
-                  ID name = pm_constant_id_lookup(compile_context, ((pm_constant_read_node_t * ) cast->child)->name);
-
-                  pushed -= 2;
-
-                  ADD_INSN1(ret, &dummy_line_node, topn, INT2FIX(pushed));
-                  ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(name));
-              } else {
-                  PM_COMPILE(node_list.nodes[index]);
-              }
-          }
-
-          if (pushed) {
-              ADD_INSN1(ret, &dummy_line_node, setn, INT2FIX(pushed));
-              for (uint8_t index = 0; index < pushed; index++) {
-                  ADD_INSN(ret, &dummy_line_node, pop);
-              }
-          }
-
-          return;
-      }
-      case PM_NEXT_NODE: {
-          pm_next_node_t *next_node = (pm_next_node_t *) node;
-          if (next_node->arguments) {
-              PM_COMPILE_NOT_POPPED((pm_node_t *)next_node->arguments);
-          }
-          else {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-          }
-
-          ADD_INSN(ret, &dummy_line_node, pop);
-          ADD_INSNL(ret, &dummy_line_node, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
-
-          return;
-      }
-      case PM_NIL_NODE:
-        PM_PUTNIL_UNLESS_POPPED
-        return;
-      case PM_NUMBERED_REFERENCE_READ_NODE: {
-          if (!popped) {
-              uint32_t reference_number = ((pm_numbered_reference_read_node_t *)node)->number;
-              ADD_INSN2(ret, &dummy_line_node, getspecial, INT2FIX(1), INT2FIX(reference_number << 1));
-          }
-          return;
-      }
-      case PM_OR_NODE: {
-          pm_or_node_t *or_node = (pm_or_node_t *) node;
-
-          LABEL *end_label = NEW_LABEL(lineno);
-          PM_COMPILE_NOT_POPPED(or_node->left);
-
-          PM_DUP_UNLESS_POPPED;
-          ADD_INSNL(ret, &dummy_line_node, branchif, end_label);
-
-          PM_POP_UNLESS_POPPED;
-          PM_COMPILE(or_node->right);
-          ADD_LABEL(ret, end_label);
-
-          return;
-      }
-      case PM_OPTIONAL_PARAMETER_NODE: {
-          pm_optional_parameter_node_t *optional_parameter_node = (pm_optional_parameter_node_t *)node;
-          PM_COMPILE_NOT_POPPED(optional_parameter_node->value);
-
-          int index = pm_lookup_local_index(iseq, compile_context, optional_parameter_node->name);
-
-          ADD_SETLOCAL(ret, &dummy_line_node, index, 0);
-
-          return;
-      }
-      case PM_PARENTHESES_NODE: {
-          pm_parentheses_node_t *parentheses_node = (pm_parentheses_node_t *) node;
-
-          if (parentheses_node->body == NULL) {
-              PM_PUTNIL_UNLESS_POPPED;
-          } else {
-              PM_COMPILE(parentheses_node->body);
-          }
-
-          return;
-      }
-      case PM_PROGRAM_NODE: {
-          pm_program_node_t *program_node = (pm_program_node_t *) node;
-
-          pm_scope_node_t scope_node;
-          pm_scope_node_init((pm_node_t *)node, &scope_node);
-          if (program_node->statements->body.size == 0) {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-              ADD_INSN(ret, &dummy_line_node, leave);
-          } else {
-              pm_scope_node_t *res_node = &scope_node;
-              PM_COMPILE((pm_node_t *) res_node);
-          }
-
-          return;
-      }
-      case PM_RANGE_NODE: {
-          pm_range_node_t *range_node = (pm_range_node_t *) node;
-          bool exclusive = (range_node->operator_loc.end - range_node->operator_loc.start) == 3;
-
-          if (pm_optimizable_range_item_p(range_node->left) && pm_optimizable_range_item_p(range_node->right))  {
-              if (!popped) {
-                  pm_node_t *left = range_node->left;
-                  pm_node_t *right = range_node->right;
-                  VALUE val = rb_range_new(
-                          left && PM_NODE_TYPE_P(left, PM_INTEGER_NODE) ? parse_integer((pm_integer_node_t *) left) : Qnil,
-                          right && PM_NODE_TYPE_P(right, PM_INTEGER_NODE) ? parse_integer((pm_integer_node_t *) right) : Qnil,
-                          exclusive
-                          );
-                  ADD_INSN1(ret, &dummy_line_node, putobject, val);
-                  RB_OBJ_WRITTEN(iseq, Qundef, val);
-              }
-          }
-          else {
-              if (range_node->left == NULL) {
-                  ADD_INSN(ret, &dummy_line_node, putnil);
-              } else {
-                  PM_COMPILE(range_node->left);
-              }
-
-              if (range_node->right == NULL) {
-                  ADD_INSN(ret, &dummy_line_node, putnil);
-              } else {
-                  PM_COMPILE(range_node->right);
-              }
-
-              if (!popped) {
-                  ADD_INSN1(ret, &dummy_line_node, newrange, INT2FIX(exclusive));
-              }
-          }
-          return;
-      }
-      case PM_RATIONAL_NODE: {
-          if (!popped) {
-              ADD_INSN1(ret, &dummy_line_node, putobject, parse_rational(node));
-          }
-          return;
-      }
-      case PM_REDO_NODE: {
-          ADD_INSNL(ret, &dummy_line_node, jump, ISEQ_COMPILE_DATA(iseq)->redo_label);
-          return;
-      }
-      case PM_REGULAR_EXPRESSION_NODE: {
-          if (!popped) {
-              pm_regular_expression_node_t *regular_expression_node = (pm_regular_expression_node_t *) node;
-              VALUE regex_str = parse_string(&regular_expression_node->unescaped);
-              int flags = 0;
-
-              if (regular_expression_node->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
-                  flags |= ONIG_OPTION_IGNORECASE;
-              }
-
-              if (regular_expression_node->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
-                  flags |= ONIG_OPTION_MULTILINE;
-              }
-
-              if (regular_expression_node->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
-                  flags |= ONIG_OPTION_EXTEND;
-              }
-
-              VALUE regex = rb_reg_new(RSTRING_PTR(regex_str), RSTRING_LEN(regex_str), flags);
-              ADD_INSN1(ret, &dummy_line_node, putobject, regex);
-          }
-          return;
-      }
-      case PM_RETURN_NODE: {
-          pm_arguments_node_t *arguments = ((pm_return_node_t *)node)->arguments;
-
-          if (arguments) {
-              PM_COMPILE((pm_node_t *)arguments);
-          }
-          else {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-          }
-
-          ADD_TRACE(ret, RUBY_EVENT_RETURN);
-          ADD_INSN(ret, &dummy_line_node, leave);
-
-          if (!popped) {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-          }
-          return;
-      }
-      case PM_SCOPE_NODE: {
-          pm_scope_node_t *scope_node = (pm_scope_node_t *)node;
-          pm_constant_id_list_t locals = scope_node->locals;
-
-          pm_parameters_node_t *parameters_node = (pm_parameters_node_t *)scope_node->parameters;
-          pm_node_list_t requireds_list = PM_EMPTY_NODE_LIST;
-          pm_node_list_t optionals_list = PM_EMPTY_NODE_LIST;
-
-          if (parameters_node) {
-              requireds_list = parameters_node->requireds;
-              optionals_list = parameters_node->optionals;
-          }
-
-          size_t size = locals.size;
-
-          // Index lookup table buffer size is only the number of the locals
-          st_table *index_lookup_table = st_init_numtable();
-
-          VALUE idtmp = 0;
-          rb_ast_id_table_t *tbl = ALLOCV(idtmp, sizeof(rb_ast_id_table_t) + size * sizeof(ID));
-          tbl->size = (int)size;
-
-          // First param gets 0, second param 1, param n...
-          // Calculate the local index for all locals
-          for (size_t i = 0; i < size; i++) {
-              pm_constant_id_t constant_id = locals.ids[i];
-              ID local = pm_constant_id_lookup(compile_context, constant_id);
-              tbl->ids[i] = local;
-              st_insert(index_lookup_table, constant_id, i);
-          }
-
-          pm_compile_context_t scope_compile_context = {
-              .parser = parser,
-              .previous = compile_context,
-              .constants = compile_context->constants,
-              .index_lookup_table = index_lookup_table
-          };
-
-          ISEQ_BODY(iseq)->param.lead_num = (int)requireds_list.size;
-          ISEQ_BODY(iseq)->param.opt_num = (int)optionals_list.size;
-          // TODO: Set all the other nums (good comment by lead_num illustrating what they are)
-          ISEQ_BODY(iseq)->param.size = (unsigned int)size;
-
-          if (optionals_list.size) {
-              LABEL **opt_table = (LABEL **)ALLOC_N(VALUE, optionals_list.size + 1);
-              LABEL *label;
-
-              // TODO: Should we make an api for NEW_LABEL where you can pass
-              // a pointer to the label it should fill out?  We already
-              // have a list of labels allocated above so it seems wasteful
-              // to do the copies.
-              for (size_t i = 0; i < optionals_list.size; i++) {
-                  label = NEW_LABEL(lineno);
-                  opt_table[i] = label;
-                  ADD_LABEL(ret, label);
-                  pm_node_t *optional_node = optionals_list.nodes[i];
-                  pm_compile_node(iseq, optional_node, ret, src, false, &scope_compile_context);
-              }
-
-              // Set the last label
-              label = NEW_LABEL(lineno);
-              opt_table[optionals_list.size] = label;
-              ADD_LABEL(ret, label);
-
-              ISEQ_BODY(iseq)->param.flags.has_opt = TRUE;
-              ISEQ_BODY(iseq)->param.opt_table = (const VALUE *)opt_table;
-          }
-
-          iseq_set_local_table(iseq, tbl);
-
-          switch (ISEQ_BODY(iseq)->type) {
-            case ISEQ_TYPE_BLOCK:
-              {
-                  LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);
-                  LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);
-
-                  start->rescued = LABEL_RESCUE_BEG;
-                  end->rescued = LABEL_RESCUE_END;
-
-                  ADD_TRACE(ret, RUBY_EVENT_B_CALL);
-                  NODE dummy_line_node = generate_dummy_line_node(ISEQ_BODY(iseq)->location.first_lineno, -1);
-                  ADD_INSN (ret, &dummy_line_node, nop);
-                  ADD_LABEL(ret, start);
-
-                  if (scope_node->body) {
-                      pm_compile_node(iseq, (pm_node_t *)(scope_node->body), ret, src, popped, &scope_compile_context);
-                  }
-                  else {
-                      ADD_INSN(ret, &dummy_line_node, putnil);
-                  }
-
-                  ADD_LABEL(ret, end);
-                  ADD_TRACE(ret, RUBY_EVENT_B_RETURN);
-                  ISEQ_COMPILE_DATA(iseq)->last_line = ISEQ_BODY(iseq)->location.code_location.end_pos.lineno;
-
-                  /* wide range catch handler must put at last */
-                  ADD_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, NULL, start);
-                  ADD_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, NULL, end);
-                  break;
-              }
-            default:
-              if (scope_node->body) {
-                  pm_compile_node(iseq, (pm_node_t *)(scope_node->body), ret, src, popped, &scope_compile_context);
-              }
-              else {
-                  ADD_INSN(ret, &dummy_line_node, putnil);
-              }
-          }
-
-          free(index_lookup_table);
-
-          ADD_INSN(ret, &dummy_line_node, leave);
-          return;
-      }
-      case PM_SELF_NODE:
-        if (!popped) {
-            ADD_INSN(ret, &dummy_line_node, putself);
-        }
-        return;
-      case PM_SINGLETON_CLASS_NODE: {
-          pm_singleton_class_node_t *singleton_class_node = (pm_singleton_class_node_t *)node;
-          pm_scope_node_t scope_node;
-          pm_scope_node_init((pm_node_t *)singleton_class_node, &scope_node);
-
-          const rb_iseq_t *singleton_class = NEW_ISEQ(&scope_node, rb_fstring_lit("singleton class"),
-                  ISEQ_TYPE_CLASS, lineno);
-
-          PM_COMPILE(singleton_class_node->expression);
-          ADD_INSN(ret, &dummy_line_node, putnil);
-          ID singletonclass;
-          CONST_ID(singletonclass, "singletonclass");
-
-          ADD_INSN3(ret, &dummy_line_node, defineclass,
-                  ID2SYM(singletonclass), singleton_class,
-                  INT2FIX(VM_DEFINECLASS_TYPE_SINGLETON_CLASS));
-          RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)singleton_class);
-
-          return;
-      }
-      case PM_SOURCE_ENCODING_NODE: {
-          const char *encoding = compile_context->parser->encoding.name;
-          if (!popped) {
-              rb_encoding *enc = rb_find_encoding(rb_str_new_cstr(encoding));
-              if (!enc) {
-                  rb_bug("Encoding not found!");
-              }
-              ADD_INSN1(ret, &dummy_line_node, putobject, rb_enc_from_encoding(enc));
-          }
-          return;
-      }
-      case PM_SOURCE_FILE_NODE: {
-          pm_source_file_node_t *source_file_node = (pm_source_file_node_t *)node;
-
-          if (!popped) {
-              VALUE filepath;
-              if (source_file_node->filepath.length == 0) {
-                  filepath = rb_fstring_lit("<compiled>");
-              }
-              else {
-                  filepath = parse_string(&source_file_node->filepath);
-              }
-
-              ADD_INSN1(ret, &dummy_line_node, putstring, filepath);
-          }
-          return;
-      }
-      case PM_SOURCE_LINE_NODE: {
-          if (!popped) {
-              ADD_INSN1(ret, &dummy_line_node, putobject, INT2FIX(lineno));
-          }
-          return;
-      }
-      case PM_SPLAT_NODE: {
-          pm_splat_node_t *splat_node = (pm_splat_node_t *)node;
-          PM_COMPILE(splat_node->expression);
-
-          ADD_INSN1(ret, &dummy_line_node, splatarray, Qtrue);
-
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_STATEMENTS_NODE: {
-          pm_statements_node_t *statements_node = (pm_statements_node_t *) node;
-          pm_node_list_t node_list = statements_node->body;
-          for (size_t index = 0; index < node_list.size - 1; index++) {
-              PM_COMPILE_POPPED(node_list.nodes[index]);
-          }
-          if (node_list.size > 0) {
-              PM_COMPILE(node_list.nodes[node_list.size - 1]);
-          }
-          else {
-              ADD_INSN(ret, &dummy_line_node, putnil);
-          }
-          return;
-      }
-      case PM_STRING_CONCAT_NODE: {
-          pm_string_concat_node_t *str_concat_node = (pm_string_concat_node_t *)node;
-          PM_COMPILE(str_concat_node->left);
-          PM_COMPILE(str_concat_node->right);
-          return;
-      }
-      case PM_STRING_NODE: {
-          if (!popped) {
-              pm_string_node_t *string_node = (pm_string_node_t *) node;
-              ADD_INSN1(ret, &dummy_line_node, putstring, parse_string(&string_node->unescaped));
-          }
-          return;
-      }
-      case PM_SYMBOL_NODE: {
-          pm_symbol_node_t *symbol_node = (pm_symbol_node_t *) node;
-          if (!popped) {
-              ADD_INSN1(ret, &dummy_line_node, putobject, ID2SYM(parse_string_symbol(&symbol_node->unescaped)));
-          }
-          return;
-      }
-      case PM_TRUE_NODE:
-        if (!popped) {
-            ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue);
-        }
-        return;
-      case PM_UNDEF_NODE: {
-          pm_undef_node_t *undef_node = (pm_undef_node_t *) node;
-
-          for (size_t index = 0; index < undef_node->names.size; index++) {
-              ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
-              ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));
-
-              PM_COMPILE(undef_node->names.nodes[index]);
-
-              ADD_SEND(ret, &dummy_line_node, id_core_undef_method, INT2NUM(2));
-
-              if (index < undef_node->names.size - 1)
-                  ADD_INSN(ret, &dummy_line_node, pop);
-          }
-
-          return;
-      }
-      case PM_UNLESS_NODE: {
-          const int line = (int)pm_newline_list_line_column(&(parser->newline_list), node->location.start).line;
-          pm_unless_node_t *unless_node = (pm_unless_node_t *)node;
-          pm_statements_node_t *node_body = unless_node->statements;
-          pm_node_t *node_else = (pm_node_t *)(unless_node->consequent);
-          pm_node_t *predicate = unless_node->predicate;
-
-          pm_compile_if(iseq, line, node_body, node_else, predicate, ret, src, popped, compile_context);
-          return;
-      }
-      case PM_UNTIL_NODE: {
-          pm_until_node_t *until_node = (pm_until_node_t *)node;
-          pm_statements_node_t *statements = until_node->statements;
-          pm_node_t *predicate = until_node->predicate;
-          pm_node_flags_t flags = node->flags;
-
-          pm_compile_while(iseq, lineno, flags, node->type, statements, predicate, ret, src, popped, compile_context);
-          return;
-      }
-      case PM_WHILE_NODE: {
-          pm_while_node_t *while_node = (pm_while_node_t *)node;
-          pm_statements_node_t *statements = while_node->statements;
-          pm_node_t *predicate = while_node->predicate;
-          pm_node_flags_t flags = node->flags;
-
-          pm_compile_while(iseq, lineno, flags, node->type, statements, predicate, ret, src, popped, compile_context);
-          return;
-      }
-      case PM_X_STRING_NODE: {
-          pm_x_string_node_t *xstring_node = (pm_x_string_node_t *) node;
-          ADD_INSN(ret, &dummy_line_node, putself);
-          ADD_INSN1(ret, &dummy_line_node, putobject, parse_string(&xstring_node->unescaped));
-          ADD_SEND_WITH_FLAG(ret, &dummy_line_node, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
-
-          PM_POP_IF_POPPED;
-          return;
-      }
-      case PM_YIELD_NODE: {
-          unsigned int flag = 0;
-          struct rb_callinfo_kwarg *keywords = NULL;
-
-          VALUE argc = INT2FIX(0);
-
-          ADD_INSN1(ret, &dummy_line_node, invokeblock, new_callinfo(iseq, 0, FIX2INT(argc), flag, keywords, FALSE));
-
-          PM_POP_IF_POPPED;
-
-          int level = 0;
-          const rb_iseq_t *tmp_iseq = iseq;
-          for (; tmp_iseq != ISEQ_BODY(iseq)->local_iseq; level++ ) {
-              tmp_iseq = ISEQ_BODY(tmp_iseq)->parent_iseq;
-          }
-
-          if (level > 0) access_outer_variables(iseq, level, rb_intern("yield"), true);
-
-          return;
-      }
-      default:
-        rb_raise(rb_eNotImpError, "node type %s not implemented", pm_node_type_to_str(PM_NODE_TYPE(node)));
-        return;
-    }
-}
-
-static VALUE
-rb_translate_prism(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, pm_compile_context_t *compile_context)
-{
-    RUBY_ASSERT(ISEQ_COMPILE_DATA(iseq));
-    RUBY_ASSERT(PM_NODE_TYPE_P(node, PM_PROGRAM_NODE) || PM_NODE_TYPE_P(node, PM_SCOPE_NODE));
-
-    pm_compile_node(iseq, node, ret, node->location.start, false, compile_context);
-    iseq_set_sequence(iseq, ret);
-    return Qnil;
-}
-
-#undef NEW_ISEQ
-#define NEW_ISEQ OLD_ISEQ
-
-#undef NEW_CHILD_ISEQ
-#define NEW_CHILD_ISEQ OLD_CHILD_ISEQ
diff --git a/prism/prism_init.c b/prism/prism_init.c
deleted file mode 100644
index ddc87fad85..0000000000
--- a/prism/prism_init.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "prism/extension.h"
-
-void ruby_init_ext(const char *name, void (*init)(void));
-
-void
-Init_Prism(void)
-{
-    ruby_init_ext("prism/prism.so", Init_prism);
-}