prism 2.0.0.rc1-x86_64-linux-gnu

data/src/node.c

@@ -0,0 +1,4515 @@
+/*----------------------------------------------------------------------------*/
+/* This file is generated by the templates/template.rb script and should not  */
+/* be modified manually. See                                                  */
+/* templates/src/node.c.erb                                                   */
+/* if you are looking to modify the                                           */
+/* template                                                                   */
+/*----------------------------------------------------------------------------*/
+
+#line 2 "prism/templates/src/node.c.erb"
+#include "prism/internal/node.h"
+
+#include "prism/internal/arena.h"
+
+#include <stdlib.h>
+
+/**
+ * Attempts to grow the node list to the next size. If there is already
+ * capacity in the list, this function does nothing. Otherwise it allocates a
+ * new array from the arena (abandon-and-copy strategy) and copies the existing
+ * data into it.
+ */
+static void
+pm_node_list_grow(pm_arena_t *arena, pm_node_list_t *list, size_t size) {
+    size_t requested_size = list->size + size;
+
+    // Guard against overflow on the addition.
+    if (requested_size < list->size) abort();
+
+    // If the requested size is within the existing capacity, return.
+    if (requested_size <= list->capacity) return;
+
+    // Otherwise, compute the next capacity by doubling.
+    size_t next_capacity = list->capacity == 0 ? 4 : list->capacity * 2;
+
+    // Guard against overflow on the doubling.
+    while (requested_size > next_capacity) {
+        if (next_capacity == 0) abort();
+        next_capacity *= 2;
+    }
+
+    // Allocate a new array from the arena (old array is abandoned).
+    pm_node_t **nodes = (pm_node_t **) pm_arena_alloc(arena, sizeof(pm_node_t *) * next_capacity, PRISM_ALIGNOF(pm_node_t *));
+
+    // Copy old data into the new array.
+    if (list->size > 0) {
+        memcpy(nodes, list->nodes, list->size * sizeof(pm_node_t *));
+    }
+
+    list->nodes = nodes;
+    list->capacity = next_capacity;
+}
+
+/**
+ * Slow path for pm_node_list_append: grow the list and append the node.
+ * Do not call directly - use pm_node_list_append instead.
+ */
+void
+pm_node_list_append_slow(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node) {
+    pm_node_list_grow(arena, list, 1);
+    list->nodes[list->size++] = node;
+}
+
+/**
+ * Prepend a new node onto the beginning of the node list.
+ */
+void
+pm_node_list_prepend(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node) {
+    pm_node_list_grow(arena, list, 1);
+    memmove(list->nodes + 1, list->nodes, list->size * sizeof(pm_node_t *));
+    list->nodes[0] = node;
+    list->size++;
+}
+
+/**
+ * Concatenate the given node list onto the end of the other node list.
+ */
+void
+pm_node_list_concat(pm_arena_t *arena, pm_node_list_t *list, pm_node_list_t *other) {
+    if (other->size > 0) {
+        pm_node_list_grow(arena, list, other->size);
+        memcpy(list->nodes + list->size, other->nodes, other->size * sizeof(pm_node_t *));
+        list->size += other->size;
+    }
+}
+
+/**
+ * Returns a string representation of the given node type.
+ */
+const char *
+pm_node_type(pm_node_type_t node_type)
+{
+    switch (node_type) {
+        case PM_ALIAS_GLOBAL_VARIABLE_NODE:
+            return "PM_ALIAS_GLOBAL_VARIABLE_NODE";
+        case PM_ALIAS_METHOD_NODE:
+            return "PM_ALIAS_METHOD_NODE";
+        case PM_ALTERNATION_PATTERN_NODE:
+            return "PM_ALTERNATION_PATTERN_NODE";
+        case PM_AND_NODE:
+            return "PM_AND_NODE";
+        case PM_ARGUMENTS_NODE:
+            return "PM_ARGUMENTS_NODE";
+        case PM_ARRAY_NODE:
+            return "PM_ARRAY_NODE";
+        case PM_ARRAY_PATTERN_NODE:
+            return "PM_ARRAY_PATTERN_NODE";
+        case PM_ASSOC_NODE:
+            return "PM_ASSOC_NODE";
+        case PM_ASSOC_SPLAT_NODE:
+            return "PM_ASSOC_SPLAT_NODE";
+        case PM_BACK_REFERENCE_READ_NODE:
+            return "PM_BACK_REFERENCE_READ_NODE";
+        case PM_BEGIN_NODE:
+            return "PM_BEGIN_NODE";
+        case PM_BLOCK_ARGUMENT_NODE:
+            return "PM_BLOCK_ARGUMENT_NODE";
+        case PM_BLOCK_LOCAL_VARIABLE_NODE:
+            return "PM_BLOCK_LOCAL_VARIABLE_NODE";
+        case PM_BLOCK_NODE:
+            return "PM_BLOCK_NODE";
+        case PM_BLOCK_PARAMETER_NODE:
+            return "PM_BLOCK_PARAMETER_NODE";
+        case PM_BLOCK_PARAMETERS_NODE:
+            return "PM_BLOCK_PARAMETERS_NODE";
+        case PM_BREAK_NODE:
+            return "PM_BREAK_NODE";
+        case PM_CALL_AND_WRITE_NODE:
+            return "PM_CALL_AND_WRITE_NODE";
+        case PM_CALL_NODE:
+            return "PM_CALL_NODE";
+        case PM_CALL_OPERATOR_WRITE_NODE:
+            return "PM_CALL_OPERATOR_WRITE_NODE";
+        case PM_CALL_OR_WRITE_NODE:
+            return "PM_CALL_OR_WRITE_NODE";
+        case PM_CALL_TARGET_NODE:
+            return "PM_CALL_TARGET_NODE";
+        case PM_CAPTURE_PATTERN_NODE:
+            return "PM_CAPTURE_PATTERN_NODE";
+        case PM_CASE_MATCH_NODE:
+            return "PM_CASE_MATCH_NODE";
+        case PM_CASE_NODE:
+            return "PM_CASE_NODE";
+        case PM_CLASS_NODE:
+            return "PM_CLASS_NODE";
+        case PM_CLASS_VARIABLE_AND_WRITE_NODE:
+            return "PM_CLASS_VARIABLE_AND_WRITE_NODE";
+        case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
+            return "PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE";
+        case PM_CLASS_VARIABLE_OR_WRITE_NODE:
+            return "PM_CLASS_VARIABLE_OR_WRITE_NODE";
+        case PM_CLASS_VARIABLE_READ_NODE:
+            return "PM_CLASS_VARIABLE_READ_NODE";
+        case PM_CLASS_VARIABLE_TARGET_NODE:
+            return "PM_CLASS_VARIABLE_TARGET_NODE";
+        case PM_CLASS_VARIABLE_WRITE_NODE:
+            return "PM_CLASS_VARIABLE_WRITE_NODE";
+        case PM_CONSTANT_AND_WRITE_NODE:
+            return "PM_CONSTANT_AND_WRITE_NODE";
+        case PM_CONSTANT_OPERATOR_WRITE_NODE:
+            return "PM_CONSTANT_OPERATOR_WRITE_NODE";
+        case PM_CONSTANT_OR_WRITE_NODE:
+            return "PM_CONSTANT_OR_WRITE_NODE";
+        case PM_CONSTANT_PATH_AND_WRITE_NODE:
+            return "PM_CONSTANT_PATH_AND_WRITE_NODE";
+        case PM_CONSTANT_PATH_NODE:
+            return "PM_CONSTANT_PATH_NODE";
+        case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE:
+            return "PM_CONSTANT_PATH_OPERATOR_WRITE_NODE";
+        case PM_CONSTANT_PATH_OR_WRITE_NODE:
+            return "PM_CONSTANT_PATH_OR_WRITE_NODE";
+        case PM_CONSTANT_PATH_TARGET_NODE:
+            return "PM_CONSTANT_PATH_TARGET_NODE";
+        case PM_CONSTANT_PATH_WRITE_NODE:
+            return "PM_CONSTANT_PATH_WRITE_NODE";
+        case PM_CONSTANT_READ_NODE:
+            return "PM_CONSTANT_READ_NODE";
+        case PM_CONSTANT_TARGET_NODE:
+            return "PM_CONSTANT_TARGET_NODE";
+        case PM_CONSTANT_WRITE_NODE:
+            return "PM_CONSTANT_WRITE_NODE";
+        case PM_DEF_NODE:
+            return "PM_DEF_NODE";
+        case PM_DEFINED_NODE:
+            return "PM_DEFINED_NODE";
+        case PM_ELSE_NODE:
+            return "PM_ELSE_NODE";
+        case PM_EMBEDDED_STATEMENTS_NODE:
+            return "PM_EMBEDDED_STATEMENTS_NODE";
+        case PM_EMBEDDED_VARIABLE_NODE:
+            return "PM_EMBEDDED_VARIABLE_NODE";
+        case PM_ENSURE_NODE:
+            return "PM_ENSURE_NODE";
+        case PM_ERROR_RECOVERY_NODE:
+            return "PM_ERROR_RECOVERY_NODE";
+        case PM_FALSE_NODE:
+            return "PM_FALSE_NODE";
+        case PM_FIND_PATTERN_NODE:
+            return "PM_FIND_PATTERN_NODE";
+        case PM_FLIP_FLOP_NODE:
+            return "PM_FLIP_FLOP_NODE";
+        case PM_FLOAT_NODE:
+            return "PM_FLOAT_NODE";
+        case PM_FOR_NODE:
+            return "PM_FOR_NODE";
+        case PM_FORWARDING_ARGUMENTS_NODE:
+            return "PM_FORWARDING_ARGUMENTS_NODE";
+        case PM_FORWARDING_PARAMETER_NODE:
+            return "PM_FORWARDING_PARAMETER_NODE";
+        case PM_FORWARDING_SUPER_NODE:
+            return "PM_FORWARDING_SUPER_NODE";
+        case PM_GLOBAL_VARIABLE_AND_WRITE_NODE:
+            return "PM_GLOBAL_VARIABLE_AND_WRITE_NODE";
+        case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
+            return "PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE";
+        case PM_GLOBAL_VARIABLE_OR_WRITE_NODE:
+            return "PM_GLOBAL_VARIABLE_OR_WRITE_NODE";
+        case PM_GLOBAL_VARIABLE_READ_NODE:
+            return "PM_GLOBAL_VARIABLE_READ_NODE";
+        case PM_GLOBAL_VARIABLE_TARGET_NODE:
+            return "PM_GLOBAL_VARIABLE_TARGET_NODE";
+        case PM_GLOBAL_VARIABLE_WRITE_NODE:
+            return "PM_GLOBAL_VARIABLE_WRITE_NODE";
+        case PM_HASH_NODE:
+            return "PM_HASH_NODE";
+        case PM_HASH_PATTERN_NODE:
+            return "PM_HASH_PATTERN_NODE";
+        case PM_IF_NODE:
+            return "PM_IF_NODE";
+        case PM_IMAGINARY_NODE:
+            return "PM_IMAGINARY_NODE";
+        case PM_IMPLICIT_NODE:
+            return "PM_IMPLICIT_NODE";
+        case PM_IMPLICIT_REST_NODE:
+            return "PM_IMPLICIT_REST_NODE";
+        case PM_IN_NODE:
+            return "PM_IN_NODE";
+        case PM_INDEX_AND_WRITE_NODE:
+            return "PM_INDEX_AND_WRITE_NODE";
+        case PM_INDEX_OPERATOR_WRITE_NODE:
+            return "PM_INDEX_OPERATOR_WRITE_NODE";
+        case PM_INDEX_OR_WRITE_NODE:
+            return "PM_INDEX_OR_WRITE_NODE";
+        case PM_INDEX_TARGET_NODE:
+            return "PM_INDEX_TARGET_NODE";
+        case PM_INSTANCE_VARIABLE_AND_WRITE_NODE:
+            return "PM_INSTANCE_VARIABLE_AND_WRITE_NODE";
+        case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
+            return "PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE";
+        case PM_INSTANCE_VARIABLE_OR_WRITE_NODE:
+            return "PM_INSTANCE_VARIABLE_OR_WRITE_NODE";
+        case PM_INSTANCE_VARIABLE_READ_NODE:
+            return "PM_INSTANCE_VARIABLE_READ_NODE";
+        case PM_INSTANCE_VARIABLE_TARGET_NODE:
+            return "PM_INSTANCE_VARIABLE_TARGET_NODE";
+        case PM_INSTANCE_VARIABLE_WRITE_NODE:
+            return "PM_INSTANCE_VARIABLE_WRITE_NODE";
+        case PM_INTEGER_NODE:
+            return "PM_INTEGER_NODE";
+        case PM_INTERPOLATED_MATCH_LAST_LINE_NODE:
+            return "PM_INTERPOLATED_MATCH_LAST_LINE_NODE";
+        case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
+            return "PM_INTERPOLATED_REGULAR_EXPRESSION_NODE";
+        case PM_INTERPOLATED_STRING_NODE:
+            return "PM_INTERPOLATED_STRING_NODE";
+        case PM_INTERPOLATED_SYMBOL_NODE:
+            return "PM_INTERPOLATED_SYMBOL_NODE";
+        case PM_INTERPOLATED_X_STRING_NODE:
+            return "PM_INTERPOLATED_X_STRING_NODE";
+        case PM_IT_LOCAL_VARIABLE_READ_NODE:
+            return "PM_IT_LOCAL_VARIABLE_READ_NODE";
+        case PM_IT_PARAMETERS_NODE:
+            return "PM_IT_PARAMETERS_NODE";
+        case PM_KEYWORD_HASH_NODE:
+            return "PM_KEYWORD_HASH_NODE";
+        case PM_KEYWORD_REST_PARAMETER_NODE:
+            return "PM_KEYWORD_REST_PARAMETER_NODE";
+        case PM_LAMBDA_NODE:
+            return "PM_LAMBDA_NODE";
+        case PM_LOCAL_VARIABLE_AND_WRITE_NODE:
+            return "PM_LOCAL_VARIABLE_AND_WRITE_NODE";
+        case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
+            return "PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE";
+        case PM_LOCAL_VARIABLE_OR_WRITE_NODE:
+            return "PM_LOCAL_VARIABLE_OR_WRITE_NODE";
+        case PM_LOCAL_VARIABLE_READ_NODE:
+            return "PM_LOCAL_VARIABLE_READ_NODE";
+        case PM_LOCAL_VARIABLE_TARGET_NODE:
+            return "PM_LOCAL_VARIABLE_TARGET_NODE";
+        case PM_LOCAL_VARIABLE_WRITE_NODE:
+            return "PM_LOCAL_VARIABLE_WRITE_NODE";
+        case PM_MATCH_LAST_LINE_NODE:
+            return "PM_MATCH_LAST_LINE_NODE";
+        case PM_MATCH_PREDICATE_NODE:
+            return "PM_MATCH_PREDICATE_NODE";
+        case PM_MATCH_REQUIRED_NODE:
+            return "PM_MATCH_REQUIRED_NODE";
+        case PM_MATCH_WRITE_NODE:
+            return "PM_MATCH_WRITE_NODE";
+        case PM_MODULE_NODE:
+            return "PM_MODULE_NODE";
+        case PM_MULTI_TARGET_NODE:
+            return "PM_MULTI_TARGET_NODE";
+        case PM_MULTI_WRITE_NODE:
+            return "PM_MULTI_WRITE_NODE";
+        case PM_NEXT_NODE:
+            return "PM_NEXT_NODE";
+        case PM_NIL_NODE:
+            return "PM_NIL_NODE";
+        case PM_NO_BLOCK_PARAMETER_NODE:
+            return "PM_NO_BLOCK_PARAMETER_NODE";
+        case PM_NO_KEYWORDS_PARAMETER_NODE:
+            return "PM_NO_KEYWORDS_PARAMETER_NODE";
+        case PM_NUMBERED_PARAMETERS_NODE:
+            return "PM_NUMBERED_PARAMETERS_NODE";
+        case PM_NUMBERED_REFERENCE_READ_NODE:
+            return "PM_NUMBERED_REFERENCE_READ_NODE";
+        case PM_OPTIONAL_KEYWORD_PARAMETER_NODE:
+            return "PM_OPTIONAL_KEYWORD_PARAMETER_NODE";
+        case PM_OPTIONAL_PARAMETER_NODE:
+            return "PM_OPTIONAL_PARAMETER_NODE";
+        case PM_OR_NODE:
+            return "PM_OR_NODE";
+        case PM_PARAMETERS_NODE:
+            return "PM_PARAMETERS_NODE";
+        case PM_PARENTHESES_NODE:
+            return "PM_PARENTHESES_NODE";
+        case PM_PINNED_EXPRESSION_NODE:
+            return "PM_PINNED_EXPRESSION_NODE";
+        case PM_PINNED_VARIABLE_NODE:
+            return "PM_PINNED_VARIABLE_NODE";
+        case PM_POST_EXECUTION_NODE:
+            return "PM_POST_EXECUTION_NODE";
+        case PM_PRE_EXECUTION_NODE:
+            return "PM_PRE_EXECUTION_NODE";
+        case PM_PROGRAM_NODE:
+            return "PM_PROGRAM_NODE";
+        case PM_RANGE_NODE:
+            return "PM_RANGE_NODE";
+        case PM_RATIONAL_NODE:
+            return "PM_RATIONAL_NODE";
+        case PM_REDO_NODE:
+            return "PM_REDO_NODE";
+        case PM_REGULAR_EXPRESSION_NODE:
+            return "PM_REGULAR_EXPRESSION_NODE";
+        case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
+            return "PM_REQUIRED_KEYWORD_PARAMETER_NODE";
+        case PM_REQUIRED_PARAMETER_NODE:
+            return "PM_REQUIRED_PARAMETER_NODE";
+        case PM_RESCUE_MODIFIER_NODE:
+            return "PM_RESCUE_MODIFIER_NODE";
+        case PM_RESCUE_NODE:
+            return "PM_RESCUE_NODE";
+        case PM_REST_PARAMETER_NODE:
+            return "PM_REST_PARAMETER_NODE";
+        case PM_RETRY_NODE:
+            return "PM_RETRY_NODE";
+        case PM_RETURN_NODE:
+            return "PM_RETURN_NODE";
+        case PM_SELF_NODE:
+            return "PM_SELF_NODE";
+        case PM_SHAREABLE_CONSTANT_NODE:
+            return "PM_SHAREABLE_CONSTANT_NODE";
+        case PM_SINGLETON_CLASS_NODE:
+            return "PM_SINGLETON_CLASS_NODE";
+        case PM_SOURCE_ENCODING_NODE:
+            return "PM_SOURCE_ENCODING_NODE";
+        case PM_SOURCE_FILE_NODE:
+            return "PM_SOURCE_FILE_NODE";
+        case PM_SOURCE_LINE_NODE:
+            return "PM_SOURCE_LINE_NODE";
+        case PM_SPLAT_NODE:
+            return "PM_SPLAT_NODE";
+        case PM_STATEMENTS_NODE:
+            return "PM_STATEMENTS_NODE";
+        case PM_STRING_NODE:
+            return "PM_STRING_NODE";
+        case PM_SUPER_NODE:
+            return "PM_SUPER_NODE";
+        case PM_SYMBOL_NODE:
+            return "PM_SYMBOL_NODE";
+        case PM_TRUE_NODE:
+            return "PM_TRUE_NODE";
+        case PM_UNDEF_NODE:
+            return "PM_UNDEF_NODE";
+        case PM_UNLESS_NODE:
+            return "PM_UNLESS_NODE";
+        case PM_UNTIL_NODE:
+            return "PM_UNTIL_NODE";
+        case PM_WHEN_NODE:
+            return "PM_WHEN_NODE";
+        case PM_WHILE_NODE:
+            return "PM_WHILE_NODE";
+        case PM_X_STRING_NODE:
+            return "PM_X_STRING_NODE";
+        case PM_YIELD_NODE:
+            return "PM_YIELD_NODE";
+    }
+    return "";
+}
+
+/**
+ * Visit each of the nodes in this subtree using the given visitor callback. The
+ * callback function will be called for each node in the subtree. If it returns
+ * false, then that node's children will not be visited. If it returns true,
+ * then the children will be visited. The data parameter is treated as an opaque
+ * pointer and is passed to the visitor callback for consumers to use as they
+ * see fit.
+ */
+void
+pm_visit_node(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void *data), void *data) {
+    if (visitor(node, data)) pm_visit_child_nodes(node, visitor, data);
+}
+
+/**
+ * Visit the children of the given node with the given callback. This is the
+ * default behavior for walking the tree that is called from pm_visit_node if
+ * the callback returns true.
+ */
+void
+pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void *data), void *data) {
+    switch (PM_NODE_TYPE(node)) {
+        case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
+            const pm_alias_global_variable_node_t *cast = (const pm_alias_global_variable_node_t *) node;
+
+            // Visit the new_name field
+            pm_visit_node((const pm_node_t *) cast->new_name, visitor, data);
+
+            // Visit the old_name field
+            pm_visit_node((const pm_node_t *) cast->old_name, visitor, data);
+
+            break;
+        }
+        case PM_ALIAS_METHOD_NODE: {
+            const pm_alias_method_node_t *cast = (const pm_alias_method_node_t *) node;
+
+            // Visit the new_name field
+            pm_visit_node((const pm_node_t *) cast->new_name, visitor, data);
+
+            // Visit the old_name field
+            pm_visit_node((const pm_node_t *) cast->old_name, visitor, data);
+
+            break;
+        }
+        case PM_ALTERNATION_PATTERN_NODE: {
+            const pm_alternation_pattern_node_t *cast = (const pm_alternation_pattern_node_t *) node;
+
+            // Visit the left field
+            pm_visit_node((const pm_node_t *) cast->left, visitor, data);
+
+            // Visit the right field
+            pm_visit_node((const pm_node_t *) cast->right, visitor, data);
+
+            break;
+        }
+        case PM_AND_NODE: {
+            const pm_and_node_t *cast = (const pm_and_node_t *) node;
+
+            // Visit the left field
+            pm_visit_node((const pm_node_t *) cast->left, visitor, data);
+
+            // Visit the right field
+            pm_visit_node((const pm_node_t *) cast->right, visitor, data);
+
+            break;
+        }
+        case PM_ARGUMENTS_NODE: {
+            const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
+
+            // Visit the arguments field
+            const pm_node_list_t *arguments = &cast->arguments;
+            for (size_t index = 0; index < arguments->size; index++) {
+                pm_visit_node(arguments->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_ARRAY_NODE: {
+            const pm_array_node_t *cast = (const pm_array_node_t *) node;
+
+            // Visit the elements field
+            const pm_node_list_t *elements = &cast->elements;
+            for (size_t index = 0; index < elements->size; index++) {
+                pm_visit_node(elements->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_ARRAY_PATTERN_NODE: {
+            const pm_array_pattern_node_t *cast = (const pm_array_pattern_node_t *) node;
+
+            // Visit the constant field
+            if (cast->constant != NULL) {
+                pm_visit_node((const pm_node_t *) cast->constant, visitor, data);
+            }
+
+            // Visit the requireds field
+            const pm_node_list_t *requireds = &cast->requireds;
+            for (size_t index = 0; index < requireds->size; index++) {
+                pm_visit_node(requireds->nodes[index], visitor, data);
+            }
+
+            // Visit the rest field
+            if (cast->rest != NULL) {
+                pm_visit_node((const pm_node_t *) cast->rest, visitor, data);
+            }
+
+            // Visit the posts field
+            const pm_node_list_t *posts = &cast->posts;
+            for (size_t index = 0; index < posts->size; index++) {
+                pm_visit_node(posts->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_ASSOC_NODE: {
+            const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
+
+            // Visit the key field
+            pm_visit_node((const pm_node_t *) cast->key, visitor, data);
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_ASSOC_SPLAT_NODE: {
+            const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
+
+            // Visit the value field
+            if (cast->value != NULL) {
+                pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+            }
+
+            break;
+        }
+        case PM_BACK_REFERENCE_READ_NODE:
+            break;
+        case PM_BEGIN_NODE: {
+            const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            // Visit the rescue_clause field
+            if (cast->rescue_clause != NULL) {
+                pm_visit_node((const pm_node_t *) cast->rescue_clause, visitor, data);
+            }
+
+            // Visit the else_clause field
+            if (cast->else_clause != NULL) {
+                pm_visit_node((const pm_node_t *) cast->else_clause, visitor, data);
+            }
+
+            // Visit the ensure_clause field
+            if (cast->ensure_clause != NULL) {
+                pm_visit_node((const pm_node_t *) cast->ensure_clause, visitor, data);
+            }
+
+            break;
+        }
+        case PM_BLOCK_ARGUMENT_NODE: {
+            const pm_block_argument_node_t *cast = (const pm_block_argument_node_t *) node;
+
+            // Visit the expression field
+            if (cast->expression != NULL) {
+                pm_visit_node((const pm_node_t *) cast->expression, visitor, data);
+            }
+
+            break;
+        }
+        case PM_BLOCK_LOCAL_VARIABLE_NODE:
+            break;
+        case PM_BLOCK_NODE: {
+            const pm_block_node_t *cast = (const pm_block_node_t *) node;
+
+            // Visit the parameters field
+            if (cast->parameters != NULL) {
+                pm_visit_node((const pm_node_t *) cast->parameters, visitor, data);
+            }
+
+            // Visit the body field
+            if (cast->body != NULL) {
+                pm_visit_node((const pm_node_t *) cast->body, visitor, data);
+            }
+
+            break;
+        }
+        case PM_BLOCK_PARAMETER_NODE:
+            break;
+        case PM_BLOCK_PARAMETERS_NODE: {
+            const pm_block_parameters_node_t *cast = (const pm_block_parameters_node_t *) node;
+
+            // Visit the parameters field
+            if (cast->parameters != NULL) {
+                pm_visit_node((const pm_node_t *) cast->parameters, visitor, data);
+            }
+
+            // Visit the locals field
+            const pm_node_list_t *locals = &cast->locals;
+            for (size_t index = 0; index < locals->size; index++) {
+                pm_visit_node(locals->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_BREAK_NODE: {
+            const pm_break_node_t *cast = (const pm_break_node_t *) node;
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            break;
+        }
+        case PM_CALL_AND_WRITE_NODE: {
+            const pm_call_and_write_node_t *cast = (const pm_call_and_write_node_t *) node;
+
+            // Visit the receiver field
+            if (cast->receiver != NULL) {
+                pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+            }
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CALL_NODE: {
+            const pm_call_node_t *cast = (const pm_call_node_t *) node;
+
+            // Visit the receiver field
+            if (cast->receiver != NULL) {
+                pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+            }
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            // Visit the block field
+            if (cast->block != NULL) {
+                pm_visit_node((const pm_node_t *) cast->block, visitor, data);
+            }
+
+            break;
+        }
+        case PM_CALL_OPERATOR_WRITE_NODE: {
+            const pm_call_operator_write_node_t *cast = (const pm_call_operator_write_node_t *) node;
+
+            // Visit the receiver field
+            if (cast->receiver != NULL) {
+                pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+            }
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CALL_OR_WRITE_NODE: {
+            const pm_call_or_write_node_t *cast = (const pm_call_or_write_node_t *) node;
+
+            // Visit the receiver field
+            if (cast->receiver != NULL) {
+                pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+            }
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CALL_TARGET_NODE: {
+            const pm_call_target_node_t *cast = (const pm_call_target_node_t *) node;
+
+            // Visit the receiver field
+            pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+
+            break;
+        }
+        case PM_CAPTURE_PATTERN_NODE: {
+            const pm_capture_pattern_node_t *cast = (const pm_capture_pattern_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            // Visit the target field
+            pm_visit_node((const pm_node_t *) cast->target, visitor, data);
+
+            break;
+        }
+        case PM_CASE_MATCH_NODE: {
+            const pm_case_match_node_t *cast = (const pm_case_match_node_t *) node;
+
+            // Visit the predicate field
+            if (cast->predicate != NULL) {
+                pm_visit_node((const pm_node_t *) cast->predicate, visitor, data);
+            }
+
+            // Visit the conditions field
+            const pm_node_list_t *conditions = &cast->conditions;
+            for (size_t index = 0; index < conditions->size; index++) {
+                pm_visit_node(conditions->nodes[index], visitor, data);
+            }
+
+            // Visit the else_clause field
+            if (cast->else_clause != NULL) {
+                pm_visit_node((const pm_node_t *) cast->else_clause, visitor, data);
+            }
+
+            break;
+        }
+        case PM_CASE_NODE: {
+            const pm_case_node_t *cast = (const pm_case_node_t *) node;
+
+            // Visit the predicate field
+            if (cast->predicate != NULL) {
+                pm_visit_node((const pm_node_t *) cast->predicate, visitor, data);
+            }
+
+            // Visit the conditions field
+            const pm_node_list_t *conditions = &cast->conditions;
+            for (size_t index = 0; index < conditions->size; index++) {
+                pm_visit_node(conditions->nodes[index], visitor, data);
+            }
+
+            // Visit the else_clause field
+            if (cast->else_clause != NULL) {
+                pm_visit_node((const pm_node_t *) cast->else_clause, visitor, data);
+            }
+
+            break;
+        }
+        case PM_CLASS_NODE: {
+            const pm_class_node_t *cast = (const pm_class_node_t *) node;
+
+            // Visit the constant_path field
+            pm_visit_node((const pm_node_t *) cast->constant_path, visitor, data);
+
+            // Visit the superclass field
+            if (cast->superclass != NULL) {
+                pm_visit_node((const pm_node_t *) cast->superclass, visitor, data);
+            }
+
+            // Visit the body field
+            if (cast->body != NULL) {
+                pm_visit_node((const pm_node_t *) cast->body, visitor, data);
+            }
+
+            break;
+        }
+        case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
+            const pm_class_variable_and_write_node_t *cast = (const pm_class_variable_and_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
+            const pm_class_variable_operator_write_node_t *cast = (const pm_class_variable_operator_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
+            const pm_class_variable_or_write_node_t *cast = (const pm_class_variable_or_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CLASS_VARIABLE_READ_NODE:
+            break;
+        case PM_CLASS_VARIABLE_TARGET_NODE:
+            break;
+        case PM_CLASS_VARIABLE_WRITE_NODE: {
+            const pm_class_variable_write_node_t *cast = (const pm_class_variable_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CONSTANT_AND_WRITE_NODE: {
+            const pm_constant_and_write_node_t *cast = (const pm_constant_and_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CONSTANT_OPERATOR_WRITE_NODE: {
+            const pm_constant_operator_write_node_t *cast = (const pm_constant_operator_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CONSTANT_OR_WRITE_NODE: {
+            const pm_constant_or_write_node_t *cast = (const pm_constant_or_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CONSTANT_PATH_AND_WRITE_NODE: {
+            const pm_constant_path_and_write_node_t *cast = (const pm_constant_path_and_write_node_t *) node;
+
+            // Visit the target field
+            pm_visit_node((const pm_node_t *) cast->target, visitor, data);
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CONSTANT_PATH_NODE: {
+            const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
+
+            // Visit the parent field
+            if (cast->parent != NULL) {
+                pm_visit_node((const pm_node_t *) cast->parent, visitor, data);
+            }
+
+            break;
+        }
+        case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
+            const pm_constant_path_operator_write_node_t *cast = (const pm_constant_path_operator_write_node_t *) node;
+
+            // Visit the target field
+            pm_visit_node((const pm_node_t *) cast->target, visitor, data);
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CONSTANT_PATH_OR_WRITE_NODE: {
+            const pm_constant_path_or_write_node_t *cast = (const pm_constant_path_or_write_node_t *) node;
+
+            // Visit the target field
+            pm_visit_node((const pm_node_t *) cast->target, visitor, data);
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CONSTANT_PATH_TARGET_NODE: {
+            const pm_constant_path_target_node_t *cast = (const pm_constant_path_target_node_t *) node;
+
+            // Visit the parent field
+            if (cast->parent != NULL) {
+                pm_visit_node((const pm_node_t *) cast->parent, visitor, data);
+            }
+
+            break;
+        }
+        case PM_CONSTANT_PATH_WRITE_NODE: {
+            const pm_constant_path_write_node_t *cast = (const pm_constant_path_write_node_t *) node;
+
+            // Visit the target field
+            pm_visit_node((const pm_node_t *) cast->target, visitor, data);
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_CONSTANT_READ_NODE:
+            break;
+        case PM_CONSTANT_TARGET_NODE:
+            break;
+        case PM_CONSTANT_WRITE_NODE: {
+            const pm_constant_write_node_t *cast = (const pm_constant_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_DEF_NODE: {
+            const pm_def_node_t *cast = (const pm_def_node_t *) node;
+
+            // Visit the receiver field
+            if (cast->receiver != NULL) {
+                pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+            }
+
+            // Visit the parameters field
+            if (cast->parameters != NULL) {
+                pm_visit_node((const pm_node_t *) cast->parameters, visitor, data);
+            }
+
+            // Visit the body field
+            if (cast->body != NULL) {
+                pm_visit_node((const pm_node_t *) cast->body, visitor, data);
+            }
+
+            break;
+        }
+        case PM_DEFINED_NODE: {
+            const pm_defined_node_t *cast = (const pm_defined_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_ELSE_NODE: {
+            const pm_else_node_t *cast = (const pm_else_node_t *) node;
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_EMBEDDED_STATEMENTS_NODE: {
+            const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) node;
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_EMBEDDED_VARIABLE_NODE: {
+            const pm_embedded_variable_node_t *cast = (const pm_embedded_variable_node_t *) node;
+
+            // Visit the variable field
+            pm_visit_node((const pm_node_t *) cast->variable, visitor, data);
+
+            break;
+        }
+        case PM_ENSURE_NODE: {
+            const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_ERROR_RECOVERY_NODE: {
+            const pm_error_recovery_node_t *cast = (const pm_error_recovery_node_t *) node;
+
+            // Visit the unexpected field
+            if (cast->unexpected != NULL) {
+                pm_visit_node((const pm_node_t *) cast->unexpected, visitor, data);
+            }
+
+            break;
+        }
+        case PM_FALSE_NODE:
+            break;
+        case PM_FIND_PATTERN_NODE: {
+            const pm_find_pattern_node_t *cast = (const pm_find_pattern_node_t *) node;
+
+            // Visit the constant field
+            if (cast->constant != NULL) {
+                pm_visit_node((const pm_node_t *) cast->constant, visitor, data);
+            }
+
+            // Visit the left field
+            pm_visit_node((const pm_node_t *) cast->left, visitor, data);
+
+            // Visit the requireds field
+            const pm_node_list_t *requireds = &cast->requireds;
+            for (size_t index = 0; index < requireds->size; index++) {
+                pm_visit_node(requireds->nodes[index], visitor, data);
+            }
+
+            // Visit the right field
+            pm_visit_node((const pm_node_t *) cast->right, visitor, data);
+
+            break;
+        }
+        case PM_FLIP_FLOP_NODE: {
+            const pm_flip_flop_node_t *cast = (const pm_flip_flop_node_t *) node;
+
+            // Visit the left field
+            if (cast->left != NULL) {
+                pm_visit_node((const pm_node_t *) cast->left, visitor, data);
+            }
+
+            // Visit the right field
+            if (cast->right != NULL) {
+                pm_visit_node((const pm_node_t *) cast->right, visitor, data);
+            }
+
+            break;
+        }
+        case PM_FLOAT_NODE:
+            break;
+        case PM_FOR_NODE: {
+            const pm_for_node_t *cast = (const pm_for_node_t *) node;
+
+            // Visit the index field
+            pm_visit_node((const pm_node_t *) cast->index, visitor, data);
+
+            // Visit the collection field
+            pm_visit_node((const pm_node_t *) cast->collection, visitor, data);
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_FORWARDING_ARGUMENTS_NODE:
+            break;
+        case PM_FORWARDING_PARAMETER_NODE:
+            break;
+        case PM_FORWARDING_SUPER_NODE: {
+            const pm_forwarding_super_node_t *cast = (const pm_forwarding_super_node_t *) node;
+
+            // Visit the block field
+            if (cast->block != NULL) {
+                pm_visit_node((const pm_node_t *) cast->block, visitor, data);
+            }
+
+            break;
+        }
+        case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
+            const pm_global_variable_and_write_node_t *cast = (const pm_global_variable_and_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
+            const pm_global_variable_operator_write_node_t *cast = (const pm_global_variable_operator_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
+            const pm_global_variable_or_write_node_t *cast = (const pm_global_variable_or_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_GLOBAL_VARIABLE_READ_NODE:
+            break;
+        case PM_GLOBAL_VARIABLE_TARGET_NODE:
+            break;
+        case PM_GLOBAL_VARIABLE_WRITE_NODE: {
+            const pm_global_variable_write_node_t *cast = (const pm_global_variable_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_HASH_NODE: {
+            const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
+
+            // Visit the elements field
+            const pm_node_list_t *elements = &cast->elements;
+            for (size_t index = 0; index < elements->size; index++) {
+                pm_visit_node(elements->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_HASH_PATTERN_NODE: {
+            const pm_hash_pattern_node_t *cast = (const pm_hash_pattern_node_t *) node;
+
+            // Visit the constant field
+            if (cast->constant != NULL) {
+                pm_visit_node((const pm_node_t *) cast->constant, visitor, data);
+            }
+
+            // Visit the elements field
+            const pm_node_list_t *elements = &cast->elements;
+            for (size_t index = 0; index < elements->size; index++) {
+                pm_visit_node(elements->nodes[index], visitor, data);
+            }
+
+            // Visit the rest field
+            if (cast->rest != NULL) {
+                pm_visit_node((const pm_node_t *) cast->rest, visitor, data);
+            }
+
+            break;
+        }
+        case PM_IF_NODE: {
+            const pm_if_node_t *cast = (const pm_if_node_t *) node;
+
+            // Visit the predicate field
+            pm_visit_node((const pm_node_t *) cast->predicate, visitor, data);
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            // Visit the subsequent field
+            if (cast->subsequent != NULL) {
+                pm_visit_node((const pm_node_t *) cast->subsequent, visitor, data);
+            }
+
+            break;
+        }
+        case PM_IMAGINARY_NODE: {
+            const pm_imaginary_node_t *cast = (const pm_imaginary_node_t *) node;
+
+            // Visit the numeric field
+            pm_visit_node((const pm_node_t *) cast->numeric, visitor, data);
+
+            break;
+        }
+        case PM_IMPLICIT_NODE: {
+            const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_IMPLICIT_REST_NODE:
+            break;
+        case PM_IN_NODE: {
+            const pm_in_node_t *cast = (const pm_in_node_t *) node;
+
+            // Visit the pattern field
+            pm_visit_node((const pm_node_t *) cast->pattern, visitor, data);
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_INDEX_AND_WRITE_NODE: {
+            const pm_index_and_write_node_t *cast = (const pm_index_and_write_node_t *) node;
+
+            // Visit the receiver field
+            if (cast->receiver != NULL) {
+                pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+            }
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            // Visit the block field
+            if (cast->block != NULL) {
+                pm_visit_node((const pm_node_t *) cast->block, visitor, data);
+            }
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_INDEX_OPERATOR_WRITE_NODE: {
+            const pm_index_operator_write_node_t *cast = (const pm_index_operator_write_node_t *) node;
+
+            // Visit the receiver field
+            if (cast->receiver != NULL) {
+                pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+            }
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            // Visit the block field
+            if (cast->block != NULL) {
+                pm_visit_node((const pm_node_t *) cast->block, visitor, data);
+            }
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_INDEX_OR_WRITE_NODE: {
+            const pm_index_or_write_node_t *cast = (const pm_index_or_write_node_t *) node;
+
+            // Visit the receiver field
+            if (cast->receiver != NULL) {
+                pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+            }
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            // Visit the block field
+            if (cast->block != NULL) {
+                pm_visit_node((const pm_node_t *) cast->block, visitor, data);
+            }
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_INDEX_TARGET_NODE: {
+            const pm_index_target_node_t *cast = (const pm_index_target_node_t *) node;
+
+            // Visit the receiver field
+            pm_visit_node((const pm_node_t *) cast->receiver, visitor, data);
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            // Visit the block field
+            if (cast->block != NULL) {
+                pm_visit_node((const pm_node_t *) cast->block, visitor, data);
+            }
+
+            break;
+        }
+        case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
+            const pm_instance_variable_and_write_node_t *cast = (const pm_instance_variable_and_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
+            const pm_instance_variable_operator_write_node_t *cast = (const pm_instance_variable_operator_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
+            const pm_instance_variable_or_write_node_t *cast = (const pm_instance_variable_or_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_INSTANCE_VARIABLE_READ_NODE:
+            break;
+        case PM_INSTANCE_VARIABLE_TARGET_NODE:
+            break;
+        case PM_INSTANCE_VARIABLE_WRITE_NODE: {
+            const pm_instance_variable_write_node_t *cast = (const pm_instance_variable_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_INTEGER_NODE:
+            break;
+        case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
+            const pm_interpolated_match_last_line_node_t *cast = (const pm_interpolated_match_last_line_node_t *) node;
+
+            // Visit the parts field
+            const pm_node_list_t *parts = &cast->parts;
+            for (size_t index = 0; index < parts->size; index++) {
+                pm_visit_node(parts->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
+            const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) node;
+
+            // Visit the parts field
+            const pm_node_list_t *parts = &cast->parts;
+            for (size_t index = 0; index < parts->size; index++) {
+                pm_visit_node(parts->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_INTERPOLATED_STRING_NODE: {
+            const pm_interpolated_string_node_t *cast = (const pm_interpolated_string_node_t *) node;
+
+            // Visit the parts field
+            const pm_node_list_t *parts = &cast->parts;
+            for (size_t index = 0; index < parts->size; index++) {
+                pm_visit_node(parts->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_INTERPOLATED_SYMBOL_NODE: {
+            const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
+
+            // Visit the parts field
+            const pm_node_list_t *parts = &cast->parts;
+            for (size_t index = 0; index < parts->size; index++) {
+                pm_visit_node(parts->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_INTERPOLATED_X_STRING_NODE: {
+            const pm_interpolated_x_string_node_t *cast = (const pm_interpolated_x_string_node_t *) node;
+
+            // Visit the parts field
+            const pm_node_list_t *parts = &cast->parts;
+            for (size_t index = 0; index < parts->size; index++) {
+                pm_visit_node(parts->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_IT_LOCAL_VARIABLE_READ_NODE:
+            break;
+        case PM_IT_PARAMETERS_NODE:
+            break;
+        case PM_KEYWORD_HASH_NODE: {
+            const pm_keyword_hash_node_t *cast = (const pm_keyword_hash_node_t *) node;
+
+            // Visit the elements field
+            const pm_node_list_t *elements = &cast->elements;
+            for (size_t index = 0; index < elements->size; index++) {
+                pm_visit_node(elements->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_KEYWORD_REST_PARAMETER_NODE:
+            break;
+        case PM_LAMBDA_NODE: {
+            const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
+
+            // Visit the parameters field
+            if (cast->parameters != NULL) {
+                pm_visit_node((const pm_node_t *) cast->parameters, visitor, data);
+            }
+
+            // Visit the body field
+            if (cast->body != NULL) {
+                pm_visit_node((const pm_node_t *) cast->body, visitor, data);
+            }
+
+            break;
+        }
+        case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
+            const pm_local_variable_and_write_node_t *cast = (const pm_local_variable_and_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
+            const pm_local_variable_operator_write_node_t *cast = (const pm_local_variable_operator_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
+            const pm_local_variable_or_write_node_t *cast = (const pm_local_variable_or_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_LOCAL_VARIABLE_READ_NODE:
+            break;
+        case PM_LOCAL_VARIABLE_TARGET_NODE:
+            break;
+        case PM_LOCAL_VARIABLE_WRITE_NODE: {
+            const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_MATCH_LAST_LINE_NODE:
+            break;
+        case PM_MATCH_PREDICATE_NODE: {
+            const pm_match_predicate_node_t *cast = (const pm_match_predicate_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            // Visit the pattern field
+            pm_visit_node((const pm_node_t *) cast->pattern, visitor, data);
+
+            break;
+        }
+        case PM_MATCH_REQUIRED_NODE: {
+            const pm_match_required_node_t *cast = (const pm_match_required_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            // Visit the pattern field
+            pm_visit_node((const pm_node_t *) cast->pattern, visitor, data);
+
+            break;
+        }
+        case PM_MATCH_WRITE_NODE: {
+            const pm_match_write_node_t *cast = (const pm_match_write_node_t *) node;
+
+            // Visit the call field
+            pm_visit_node((const pm_node_t *) cast->call, visitor, data);
+
+            // Visit the targets field
+            const pm_node_list_t *targets = &cast->targets;
+            for (size_t index = 0; index < targets->size; index++) {
+                pm_visit_node(targets->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_MODULE_NODE: {
+            const pm_module_node_t *cast = (const pm_module_node_t *) node;
+
+            // Visit the constant_path field
+            pm_visit_node((const pm_node_t *) cast->constant_path, visitor, data);
+
+            // Visit the body field
+            if (cast->body != NULL) {
+                pm_visit_node((const pm_node_t *) cast->body, visitor, data);
+            }
+
+            break;
+        }
+        case PM_MULTI_TARGET_NODE: {
+            const pm_multi_target_node_t *cast = (const pm_multi_target_node_t *) node;
+
+            // Visit the lefts field
+            const pm_node_list_t *lefts = &cast->lefts;
+            for (size_t index = 0; index < lefts->size; index++) {
+                pm_visit_node(lefts->nodes[index], visitor, data);
+            }
+
+            // Visit the rest field
+            if (cast->rest != NULL) {
+                pm_visit_node((const pm_node_t *) cast->rest, visitor, data);
+            }
+
+            // Visit the rights field
+            const pm_node_list_t *rights = &cast->rights;
+            for (size_t index = 0; index < rights->size; index++) {
+                pm_visit_node(rights->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_MULTI_WRITE_NODE: {
+            const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
+
+            // Visit the lefts field
+            const pm_node_list_t *lefts = &cast->lefts;
+            for (size_t index = 0; index < lefts->size; index++) {
+                pm_visit_node(lefts->nodes[index], visitor, data);
+            }
+
+            // Visit the rest field
+            if (cast->rest != NULL) {
+                pm_visit_node((const pm_node_t *) cast->rest, visitor, data);
+            }
+
+            // Visit the rights field
+            const pm_node_list_t *rights = &cast->rights;
+            for (size_t index = 0; index < rights->size; index++) {
+                pm_visit_node(rights->nodes[index], visitor, data);
+            }
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_NEXT_NODE: {
+            const pm_next_node_t *cast = (const pm_next_node_t *) node;
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            break;
+        }
+        case PM_NIL_NODE:
+            break;
+        case PM_NO_BLOCK_PARAMETER_NODE:
+            break;
+        case PM_NO_KEYWORDS_PARAMETER_NODE:
+            break;
+        case PM_NUMBERED_PARAMETERS_NODE:
+            break;
+        case PM_NUMBERED_REFERENCE_READ_NODE:
+            break;
+        case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
+            const pm_optional_keyword_parameter_node_t *cast = (const pm_optional_keyword_parameter_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_OPTIONAL_PARAMETER_NODE: {
+            const pm_optional_parameter_node_t *cast = (const pm_optional_parameter_node_t *) node;
+
+            // Visit the value field
+            pm_visit_node((const pm_node_t *) cast->value, visitor, data);
+
+            break;
+        }
+        case PM_OR_NODE: {
+            const pm_or_node_t *cast = (const pm_or_node_t *) node;
+
+            // Visit the left field
+            pm_visit_node((const pm_node_t *) cast->left, visitor, data);
+
+            // Visit the right field
+            pm_visit_node((const pm_node_t *) cast->right, visitor, data);
+
+            break;
+        }
+        case PM_PARAMETERS_NODE: {
+            const pm_parameters_node_t *cast = (const pm_parameters_node_t *) node;
+
+            // Visit the requireds field
+            const pm_node_list_t *requireds = &cast->requireds;
+            for (size_t index = 0; index < requireds->size; index++) {
+                pm_visit_node(requireds->nodes[index], visitor, data);
+            }
+
+            // Visit the optionals field
+            const pm_node_list_t *optionals = &cast->optionals;
+            for (size_t index = 0; index < optionals->size; index++) {
+                pm_visit_node(optionals->nodes[index], visitor, data);
+            }
+
+            // Visit the rest field
+            if (cast->rest != NULL) {
+                pm_visit_node((const pm_node_t *) cast->rest, visitor, data);
+            }
+
+            // Visit the posts field
+            const pm_node_list_t *posts = &cast->posts;
+            for (size_t index = 0; index < posts->size; index++) {
+                pm_visit_node(posts->nodes[index], visitor, data);
+            }
+
+            // Visit the keywords field
+            const pm_node_list_t *keywords = &cast->keywords;
+            for (size_t index = 0; index < keywords->size; index++) {
+                pm_visit_node(keywords->nodes[index], visitor, data);
+            }
+
+            // Visit the keyword_rest field
+            if (cast->keyword_rest != NULL) {
+                pm_visit_node((const pm_node_t *) cast->keyword_rest, visitor, data);
+            }
+
+            // Visit the block field
+            if (cast->block != NULL) {
+                pm_visit_node((const pm_node_t *) cast->block, visitor, data);
+            }
+
+            break;
+        }
+        case PM_PARENTHESES_NODE: {
+            const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
+
+            // Visit the body field
+            if (cast->body != NULL) {
+                pm_visit_node((const pm_node_t *) cast->body, visitor, data);
+            }
+
+            break;
+        }
+        case PM_PINNED_EXPRESSION_NODE: {
+            const pm_pinned_expression_node_t *cast = (const pm_pinned_expression_node_t *) node;
+
+            // Visit the expression field
+            pm_visit_node((const pm_node_t *) cast->expression, visitor, data);
+
+            break;
+        }
+        case PM_PINNED_VARIABLE_NODE: {
+            const pm_pinned_variable_node_t *cast = (const pm_pinned_variable_node_t *) node;
+
+            // Visit the variable field
+            pm_visit_node((const pm_node_t *) cast->variable, visitor, data);
+
+            break;
+        }
+        case PM_POST_EXECUTION_NODE: {
+            const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) node;
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_PRE_EXECUTION_NODE: {
+            const pm_pre_execution_node_t *cast = (const pm_pre_execution_node_t *) node;
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_PROGRAM_NODE: {
+            const pm_program_node_t *cast = (const pm_program_node_t *) node;
+
+            // Visit the statements field
+            pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+
+            break;
+        }
+        case PM_RANGE_NODE: {
+            const pm_range_node_t *cast = (const pm_range_node_t *) node;
+
+            // Visit the left field
+            if (cast->left != NULL) {
+                pm_visit_node((const pm_node_t *) cast->left, visitor, data);
+            }
+
+            // Visit the right field
+            if (cast->right != NULL) {
+                pm_visit_node((const pm_node_t *) cast->right, visitor, data);
+            }
+
+            break;
+        }
+        case PM_RATIONAL_NODE:
+            break;
+        case PM_REDO_NODE:
+            break;
+        case PM_REGULAR_EXPRESSION_NODE:
+            break;
+        case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
+            break;
+        case PM_REQUIRED_PARAMETER_NODE:
+            break;
+        case PM_RESCUE_MODIFIER_NODE: {
+            const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
+
+            // Visit the expression field
+            pm_visit_node((const pm_node_t *) cast->expression, visitor, data);
+
+            // Visit the rescue_expression field
+            pm_visit_node((const pm_node_t *) cast->rescue_expression, visitor, data);
+
+            break;
+        }
+        case PM_RESCUE_NODE: {
+            const pm_rescue_node_t *cast = (const pm_rescue_node_t *) node;
+
+            // Visit the exceptions field
+            const pm_node_list_t *exceptions = &cast->exceptions;
+            for (size_t index = 0; index < exceptions->size; index++) {
+                pm_visit_node(exceptions->nodes[index], visitor, data);
+            }
+
+            // Visit the reference field
+            if (cast->reference != NULL) {
+                pm_visit_node((const pm_node_t *) cast->reference, visitor, data);
+            }
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            // Visit the subsequent field
+            if (cast->subsequent != NULL) {
+                pm_visit_node((const pm_node_t *) cast->subsequent, visitor, data);
+            }
+
+            break;
+        }
+        case PM_REST_PARAMETER_NODE:
+            break;
+        case PM_RETRY_NODE:
+            break;
+        case PM_RETURN_NODE: {
+            const pm_return_node_t *cast = (const pm_return_node_t *) node;
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            break;
+        }
+        case PM_SELF_NODE:
+            break;
+        case PM_SHAREABLE_CONSTANT_NODE: {
+            const pm_shareable_constant_node_t *cast = (const pm_shareable_constant_node_t *) node;
+
+            // Visit the write field
+            pm_visit_node((const pm_node_t *) cast->write, visitor, data);
+
+            break;
+        }
+        case PM_SINGLETON_CLASS_NODE: {
+            const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
+
+            // Visit the expression field
+            pm_visit_node((const pm_node_t *) cast->expression, visitor, data);
+
+            // Visit the body field
+            if (cast->body != NULL) {
+                pm_visit_node((const pm_node_t *) cast->body, visitor, data);
+            }
+
+            break;
+        }
+        case PM_SOURCE_ENCODING_NODE:
+            break;
+        case PM_SOURCE_FILE_NODE:
+            break;
+        case PM_SOURCE_LINE_NODE:
+            break;
+        case PM_SPLAT_NODE: {
+            const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
+
+            // Visit the expression field
+            if (cast->expression != NULL) {
+                pm_visit_node((const pm_node_t *) cast->expression, visitor, data);
+            }
+
+            break;
+        }
+        case PM_STATEMENTS_NODE: {
+            const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
+
+            // Visit the body field
+            const pm_node_list_t *body = &cast->body;
+            for (size_t index = 0; index < body->size; index++) {
+                pm_visit_node(body->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_STRING_NODE:
+            break;
+        case PM_SUPER_NODE: {
+            const pm_super_node_t *cast = (const pm_super_node_t *) node;
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            // Visit the block field
+            if (cast->block != NULL) {
+                pm_visit_node((const pm_node_t *) cast->block, visitor, data);
+            }
+
+            break;
+        }
+        case PM_SYMBOL_NODE:
+            break;
+        case PM_TRUE_NODE:
+            break;
+        case PM_UNDEF_NODE: {
+            const pm_undef_node_t *cast = (const pm_undef_node_t *) node;
+
+            // Visit the names field
+            const pm_node_list_t *names = &cast->names;
+            for (size_t index = 0; index < names->size; index++) {
+                pm_visit_node(names->nodes[index], visitor, data);
+            }
+
+            break;
+        }
+        case PM_UNLESS_NODE: {
+            const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
+
+            // Visit the predicate field
+            pm_visit_node((const pm_node_t *) cast->predicate, visitor, data);
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            // Visit the else_clause field
+            if (cast->else_clause != NULL) {
+                pm_visit_node((const pm_node_t *) cast->else_clause, visitor, data);
+            }
+
+            break;
+        }
+        case PM_UNTIL_NODE: {
+            const pm_until_node_t *cast = (const pm_until_node_t *) node;
+
+            // Visit the predicate field
+            pm_visit_node((const pm_node_t *) cast->predicate, visitor, data);
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_WHEN_NODE: {
+            const pm_when_node_t *cast = (const pm_when_node_t *) node;
+
+            // Visit the conditions field
+            const pm_node_list_t *conditions = &cast->conditions;
+            for (size_t index = 0; index < conditions->size; index++) {
+                pm_visit_node(conditions->nodes[index], visitor, data);
+            }
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_WHILE_NODE: {
+            const pm_while_node_t *cast = (const pm_while_node_t *) node;
+
+            // Visit the predicate field
+            pm_visit_node((const pm_node_t *) cast->predicate, visitor, data);
+
+            // Visit the statements field
+            if (cast->statements != NULL) {
+                pm_visit_node((const pm_node_t *) cast->statements, visitor, data);
+            }
+
+            break;
+        }
+        case PM_X_STRING_NODE:
+            break;
+        case PM_YIELD_NODE: {
+            const pm_yield_node_t *cast = (const pm_yield_node_t *) node;
+
+            // Visit the arguments field
+            if (cast->arguments != NULL) {
+                pm_visit_node((const pm_node_t *) cast->arguments, visitor, data);
+            }
+
+            break;
+        }
+        case PM_SCOPE_NODE:
+            break;
+    }
+}
+
+/**
+ * Allocate and initialize a new AliasGlobalVariableNode node.
+ */
+pm_alias_global_variable_node_t *
+pm_alias_global_variable_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *new_name, struct pm_node *old_name, pm_location_t keyword_loc) {
+    pm_alias_global_variable_node_t *node = (pm_alias_global_variable_node_t *) pm_arena_alloc(arena, sizeof(pm_alias_global_variable_node_t), PRISM_ALIGNOF(pm_alias_global_variable_node_t));
+
+    *node = (pm_alias_global_variable_node_t) {
+        .base = { .type = PM_ALIAS_GLOBAL_VARIABLE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .new_name = new_name,
+        .old_name = old_name,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new AliasMethodNode node.
+ */
+pm_alias_method_node_t *
+pm_alias_method_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *new_name, struct pm_node *old_name, pm_location_t keyword_loc) {
+    pm_alias_method_node_t *node = (pm_alias_method_node_t *) pm_arena_alloc(arena, sizeof(pm_alias_method_node_t), PRISM_ALIGNOF(pm_alias_method_node_t));
+
+    *node = (pm_alias_method_node_t) {
+        .base = { .type = PM_ALIAS_METHOD_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .new_name = new_name,
+        .old_name = old_name,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new AlternationPatternNode node.
+ */
+pm_alternation_pattern_node_t *
+pm_alternation_pattern_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *left, struct pm_node *right, pm_location_t operator_loc) {
+    pm_alternation_pattern_node_t *node = (pm_alternation_pattern_node_t *) pm_arena_alloc(arena, sizeof(pm_alternation_pattern_node_t), PRISM_ALIGNOF(pm_alternation_pattern_node_t));
+
+    *node = (pm_alternation_pattern_node_t) {
+        .base = { .type = PM_ALTERNATION_PATTERN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .left = left,
+        .right = right,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new AndNode node.
+ */
+pm_and_node_t *
+pm_and_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *left, struct pm_node *right, pm_location_t operator_loc) {
+    pm_and_node_t *node = (pm_and_node_t *) pm_arena_alloc(arena, sizeof(pm_and_node_t), PRISM_ALIGNOF(pm_and_node_t));
+
+    *node = (pm_and_node_t) {
+        .base = { .type = PM_AND_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .left = left,
+        .right = right,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ArgumentsNode node.
+ */
+pm_arguments_node_t *
+pm_arguments_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_node_list_t arguments) {
+    pm_arguments_node_t *node = (pm_arguments_node_t *) pm_arena_alloc(arena, sizeof(pm_arguments_node_t), PRISM_ALIGNOF(pm_arguments_node_t));
+
+    *node = (pm_arguments_node_t) {
+        .base = { .type = PM_ARGUMENTS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .arguments = arguments
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ArrayNode node.
+ */
+pm_array_node_t *
+pm_array_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_node_list_t elements, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_array_node_t *node = (pm_array_node_t *) pm_arena_alloc(arena, sizeof(pm_array_node_t), PRISM_ALIGNOF(pm_array_node_t));
+
+    *node = (pm_array_node_t) {
+        .base = { .type = PM_ARRAY_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .elements = elements,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ArrayPatternNode node.
+ */
+pm_array_pattern_node_t *
+pm_array_pattern_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *constant, pm_node_list_t requireds, struct pm_node *rest, pm_node_list_t posts, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_array_pattern_node_t *node = (pm_array_pattern_node_t *) pm_arena_alloc(arena, sizeof(pm_array_pattern_node_t), PRISM_ALIGNOF(pm_array_pattern_node_t));
+
+    *node = (pm_array_pattern_node_t) {
+        .base = { .type = PM_ARRAY_PATTERN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .constant = constant,
+        .requireds = requireds,
+        .rest = rest,
+        .posts = posts,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new AssocNode node.
+ */
+pm_assoc_node_t *
+pm_assoc_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *key, struct pm_node *value, pm_location_t operator_loc) {
+    pm_assoc_node_t *node = (pm_assoc_node_t *) pm_arena_alloc(arena, sizeof(pm_assoc_node_t), PRISM_ALIGNOF(pm_assoc_node_t));
+
+    *node = (pm_assoc_node_t) {
+        .base = { .type = PM_ASSOC_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .key = key,
+        .value = value,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new AssocSplatNode node.
+ */
+pm_assoc_splat_node_t *
+pm_assoc_splat_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *value, pm_location_t operator_loc) {
+    pm_assoc_splat_node_t *node = (pm_assoc_splat_node_t *) pm_arena_alloc(arena, sizeof(pm_assoc_splat_node_t), PRISM_ALIGNOF(pm_assoc_splat_node_t));
+
+    *node = (pm_assoc_splat_node_t) {
+        .base = { .type = PM_ASSOC_SPLAT_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .value = value,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new BackReferenceReadNode node.
+ */
+pm_back_reference_read_node_t *
+pm_back_reference_read_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_back_reference_read_node_t *node = (pm_back_reference_read_node_t *) pm_arena_alloc(arena, sizeof(pm_back_reference_read_node_t), PRISM_ALIGNOF(pm_back_reference_read_node_t));
+
+    *node = (pm_back_reference_read_node_t) {
+        .base = { .type = PM_BACK_REFERENCE_READ_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new BeginNode node.
+ */
+pm_begin_node_t *
+pm_begin_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t begin_keyword_loc, struct pm_statements_node *statements, struct pm_rescue_node *rescue_clause, struct pm_else_node *else_clause, struct pm_ensure_node *ensure_clause, pm_location_t end_keyword_loc) {
+    pm_begin_node_t *node = (pm_begin_node_t *) pm_arena_alloc(arena, sizeof(pm_begin_node_t), PRISM_ALIGNOF(pm_begin_node_t));
+
+    *node = (pm_begin_node_t) {
+        .base = { .type = PM_BEGIN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .begin_keyword_loc = begin_keyword_loc,
+        .statements = statements,
+        .rescue_clause = rescue_clause,
+        .else_clause = else_clause,
+        .ensure_clause = ensure_clause,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new BlockArgumentNode node.
+ */
+pm_block_argument_node_t *
+pm_block_argument_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *expression, pm_location_t operator_loc) {
+    pm_block_argument_node_t *node = (pm_block_argument_node_t *) pm_arena_alloc(arena, sizeof(pm_block_argument_node_t), PRISM_ALIGNOF(pm_block_argument_node_t));
+
+    *node = (pm_block_argument_node_t) {
+        .base = { .type = PM_BLOCK_ARGUMENT_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .expression = expression,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new BlockLocalVariableNode node.
+ */
+pm_block_local_variable_node_t *
+pm_block_local_variable_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_block_local_variable_node_t *node = (pm_block_local_variable_node_t *) pm_arena_alloc(arena, sizeof(pm_block_local_variable_node_t), PRISM_ALIGNOF(pm_block_local_variable_node_t));
+
+    *node = (pm_block_local_variable_node_t) {
+        .base = { .type = PM_BLOCK_LOCAL_VARIABLE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new BlockNode node.
+ */
+pm_block_node_t *
+pm_block_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_list_t locals, struct pm_node *parameters, struct pm_node *body, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_block_node_t *node = (pm_block_node_t *) pm_arena_alloc(arena, sizeof(pm_block_node_t), PRISM_ALIGNOF(pm_block_node_t));
+
+    *node = (pm_block_node_t) {
+        .base = { .type = PM_BLOCK_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .locals = locals,
+        .parameters = parameters,
+        .body = body,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new BlockParameterNode node.
+ */
+pm_block_parameter_node_t *
+pm_block_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc) {
+    pm_block_parameter_node_t *node = (pm_block_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_block_parameter_node_t), PRISM_ALIGNOF(pm_block_parameter_node_t));
+
+    *node = (pm_block_parameter_node_t) {
+        .base = { .type = PM_BLOCK_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new BlockParametersNode node.
+ */
+pm_block_parameters_node_t *
+pm_block_parameters_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_parameters_node *parameters, pm_node_list_t locals, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_block_parameters_node_t *node = (pm_block_parameters_node_t *) pm_arena_alloc(arena, sizeof(pm_block_parameters_node_t), PRISM_ALIGNOF(pm_block_parameters_node_t));
+
+    *node = (pm_block_parameters_node_t) {
+        .base = { .type = PM_BLOCK_PARAMETERS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .parameters = parameters,
+        .locals = locals,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new BreakNode node.
+ */
+pm_break_node_t *
+pm_break_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_arguments_node *arguments, pm_location_t keyword_loc) {
+    pm_break_node_t *node = (pm_break_node_t *) pm_arena_alloc(arena, sizeof(pm_break_node_t), PRISM_ALIGNOF(pm_break_node_t));
+
+    *node = (pm_break_node_t) {
+        .base = { .type = PM_BREAK_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .arguments = arguments,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new CallAndWriteNode node.
+ */
+pm_call_and_write_node_t *
+pm_call_and_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t call_operator_loc, pm_location_t message_loc, pm_constant_id_t read_name, pm_constant_id_t write_name, pm_location_t operator_loc, struct pm_node *value) {
+    pm_call_and_write_node_t *node = (pm_call_and_write_node_t *) pm_arena_alloc(arena, sizeof(pm_call_and_write_node_t), PRISM_ALIGNOF(pm_call_and_write_node_t));
+
+    *node = (pm_call_and_write_node_t) {
+        .base = { .type = PM_CALL_AND_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .call_operator_loc = call_operator_loc,
+        .message_loc = message_loc,
+        .read_name = read_name,
+        .write_name = write_name,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new CallNode node.
+ */
+pm_call_node_t *
+pm_call_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t call_operator_loc, pm_constant_id_t name, pm_location_t message_loc, pm_location_t opening_loc, struct pm_arguments_node *arguments, pm_location_t closing_loc, pm_location_t equal_loc, struct pm_node *block) {
+    pm_call_node_t *node = (pm_call_node_t *) pm_arena_alloc(arena, sizeof(pm_call_node_t), PRISM_ALIGNOF(pm_call_node_t));
+
+    *node = (pm_call_node_t) {
+        .base = { .type = PM_CALL_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .call_operator_loc = call_operator_loc,
+        .name = name,
+        .message_loc = message_loc,
+        .opening_loc = opening_loc,
+        .arguments = arguments,
+        .closing_loc = closing_loc,
+        .equal_loc = equal_loc,
+        .block = block
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new CallOperatorWriteNode node.
+ */
+pm_call_operator_write_node_t *
+pm_call_operator_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t call_operator_loc, pm_location_t message_loc, pm_constant_id_t read_name, pm_constant_id_t write_name, pm_constant_id_t binary_operator, pm_location_t binary_operator_loc, struct pm_node *value) {
+    pm_call_operator_write_node_t *node = (pm_call_operator_write_node_t *) pm_arena_alloc(arena, sizeof(pm_call_operator_write_node_t), PRISM_ALIGNOF(pm_call_operator_write_node_t));
+
+    *node = (pm_call_operator_write_node_t) {
+        .base = { .type = PM_CALL_OPERATOR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .call_operator_loc = call_operator_loc,
+        .message_loc = message_loc,
+        .read_name = read_name,
+        .write_name = write_name,
+        .binary_operator = binary_operator,
+        .binary_operator_loc = binary_operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new CallOrWriteNode node.
+ */
+pm_call_or_write_node_t *
+pm_call_or_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t call_operator_loc, pm_location_t message_loc, pm_constant_id_t read_name, pm_constant_id_t write_name, pm_location_t operator_loc, struct pm_node *value) {
+    pm_call_or_write_node_t *node = (pm_call_or_write_node_t *) pm_arena_alloc(arena, sizeof(pm_call_or_write_node_t), PRISM_ALIGNOF(pm_call_or_write_node_t));
+
+    *node = (pm_call_or_write_node_t) {
+        .base = { .type = PM_CALL_OR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .call_operator_loc = call_operator_loc,
+        .message_loc = message_loc,
+        .read_name = read_name,
+        .write_name = write_name,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new CallTargetNode node.
+ */
+pm_call_target_node_t *
+pm_call_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t call_operator_loc, pm_constant_id_t name, pm_location_t message_loc) {
+    pm_call_target_node_t *node = (pm_call_target_node_t *) pm_arena_alloc(arena, sizeof(pm_call_target_node_t), PRISM_ALIGNOF(pm_call_target_node_t));
+
+    *node = (pm_call_target_node_t) {
+        .base = { .type = PM_CALL_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .call_operator_loc = call_operator_loc,
+        .name = name,
+        .message_loc = message_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new CapturePatternNode node.
+ */
+pm_capture_pattern_node_t *
+pm_capture_pattern_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *value, struct pm_local_variable_target_node *target, pm_location_t operator_loc) {
+    pm_capture_pattern_node_t *node = (pm_capture_pattern_node_t *) pm_arena_alloc(arena, sizeof(pm_capture_pattern_node_t), PRISM_ALIGNOF(pm_capture_pattern_node_t));
+
+    *node = (pm_capture_pattern_node_t) {
+        .base = { .type = PM_CAPTURE_PATTERN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .value = value,
+        .target = target,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new CaseMatchNode node.
+ */
+pm_case_match_node_t *
+pm_case_match_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *predicate, pm_node_list_t conditions, struct pm_else_node *else_clause, pm_location_t case_keyword_loc, pm_location_t end_keyword_loc) {
+    pm_case_match_node_t *node = (pm_case_match_node_t *) pm_arena_alloc(arena, sizeof(pm_case_match_node_t), PRISM_ALIGNOF(pm_case_match_node_t));
+
+    *node = (pm_case_match_node_t) {
+        .base = { .type = PM_CASE_MATCH_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .predicate = predicate,
+        .conditions = conditions,
+        .else_clause = else_clause,
+        .case_keyword_loc = case_keyword_loc,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new CaseNode node.
+ */
+pm_case_node_t *
+pm_case_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *predicate, pm_node_list_t conditions, struct pm_else_node *else_clause, pm_location_t case_keyword_loc, pm_location_t end_keyword_loc) {
+    pm_case_node_t *node = (pm_case_node_t *) pm_arena_alloc(arena, sizeof(pm_case_node_t), PRISM_ALIGNOF(pm_case_node_t));
+
+    *node = (pm_case_node_t) {
+        .base = { .type = PM_CASE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .predicate = predicate,
+        .conditions = conditions,
+        .else_clause = else_clause,
+        .case_keyword_loc = case_keyword_loc,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ClassNode node.
+ */
+pm_class_node_t *
+pm_class_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_list_t locals, pm_location_t class_keyword_loc, struct pm_node *constant_path, pm_location_t inheritance_operator_loc, struct pm_node *superclass, struct pm_node *body, pm_location_t end_keyword_loc, pm_constant_id_t name) {
+    pm_class_node_t *node = (pm_class_node_t *) pm_arena_alloc(arena, sizeof(pm_class_node_t), PRISM_ALIGNOF(pm_class_node_t));
+
+    *node = (pm_class_node_t) {
+        .base = { .type = PM_CLASS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .locals = locals,
+        .class_keyword_loc = class_keyword_loc,
+        .constant_path = constant_path,
+        .inheritance_operator_loc = inheritance_operator_loc,
+        .superclass = superclass,
+        .body = body,
+        .end_keyword_loc = end_keyword_loc,
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ClassVariableAndWriteNode node.
+ */
+pm_class_variable_and_write_node_t *
+pm_class_variable_and_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_class_variable_and_write_node_t *node = (pm_class_variable_and_write_node_t *) pm_arena_alloc(arena, sizeof(pm_class_variable_and_write_node_t), PRISM_ALIGNOF(pm_class_variable_and_write_node_t));
+
+    *node = (pm_class_variable_and_write_node_t) {
+        .base = { .type = PM_CLASS_VARIABLE_AND_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ClassVariableOperatorWriteNode node.
+ */
+pm_class_variable_operator_write_node_t *
+pm_class_variable_operator_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t binary_operator_loc, struct pm_node *value, pm_constant_id_t binary_operator) {
+    pm_class_variable_operator_write_node_t *node = (pm_class_variable_operator_write_node_t *) pm_arena_alloc(arena, sizeof(pm_class_variable_operator_write_node_t), PRISM_ALIGNOF(pm_class_variable_operator_write_node_t));
+
+    *node = (pm_class_variable_operator_write_node_t) {
+        .base = { .type = PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .binary_operator_loc = binary_operator_loc,
+        .value = value,
+        .binary_operator = binary_operator
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ClassVariableOrWriteNode node.
+ */
+pm_class_variable_or_write_node_t *
+pm_class_variable_or_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_class_variable_or_write_node_t *node = (pm_class_variable_or_write_node_t *) pm_arena_alloc(arena, sizeof(pm_class_variable_or_write_node_t), PRISM_ALIGNOF(pm_class_variable_or_write_node_t));
+
+    *node = (pm_class_variable_or_write_node_t) {
+        .base = { .type = PM_CLASS_VARIABLE_OR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ClassVariableReadNode node.
+ */
+pm_class_variable_read_node_t *
+pm_class_variable_read_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_class_variable_read_node_t *node = (pm_class_variable_read_node_t *) pm_arena_alloc(arena, sizeof(pm_class_variable_read_node_t), PRISM_ALIGNOF(pm_class_variable_read_node_t));
+
+    *node = (pm_class_variable_read_node_t) {
+        .base = { .type = PM_CLASS_VARIABLE_READ_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ClassVariableTargetNode node.
+ */
+pm_class_variable_target_node_t *
+pm_class_variable_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_class_variable_target_node_t *node = (pm_class_variable_target_node_t *) pm_arena_alloc(arena, sizeof(pm_class_variable_target_node_t), PRISM_ALIGNOF(pm_class_variable_target_node_t));
+
+    *node = (pm_class_variable_target_node_t) {
+        .base = { .type = PM_CLASS_VARIABLE_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ClassVariableWriteNode node.
+ */
+pm_class_variable_write_node_t *
+pm_class_variable_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, struct pm_node *value, pm_location_t operator_loc) {
+    pm_class_variable_write_node_t *node = (pm_class_variable_write_node_t *) pm_arena_alloc(arena, sizeof(pm_class_variable_write_node_t), PRISM_ALIGNOF(pm_class_variable_write_node_t));
+
+    *node = (pm_class_variable_write_node_t) {
+        .base = { .type = PM_CLASS_VARIABLE_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .value = value,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantAndWriteNode node.
+ */
+pm_constant_and_write_node_t *
+pm_constant_and_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_constant_and_write_node_t *node = (pm_constant_and_write_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_and_write_node_t), PRISM_ALIGNOF(pm_constant_and_write_node_t));
+
+    *node = (pm_constant_and_write_node_t) {
+        .base = { .type = PM_CONSTANT_AND_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantOperatorWriteNode node.
+ */
+pm_constant_operator_write_node_t *
+pm_constant_operator_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t binary_operator_loc, struct pm_node *value, pm_constant_id_t binary_operator) {
+    pm_constant_operator_write_node_t *node = (pm_constant_operator_write_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_operator_write_node_t), PRISM_ALIGNOF(pm_constant_operator_write_node_t));
+
+    *node = (pm_constant_operator_write_node_t) {
+        .base = { .type = PM_CONSTANT_OPERATOR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .binary_operator_loc = binary_operator_loc,
+        .value = value,
+        .binary_operator = binary_operator
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantOrWriteNode node.
+ */
+pm_constant_or_write_node_t *
+pm_constant_or_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_constant_or_write_node_t *node = (pm_constant_or_write_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_or_write_node_t), PRISM_ALIGNOF(pm_constant_or_write_node_t));
+
+    *node = (pm_constant_or_write_node_t) {
+        .base = { .type = PM_CONSTANT_OR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantPathAndWriteNode node.
+ */
+pm_constant_path_and_write_node_t *
+pm_constant_path_and_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_constant_path_node *target, pm_location_t operator_loc, struct pm_node *value) {
+    pm_constant_path_and_write_node_t *node = (pm_constant_path_and_write_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_path_and_write_node_t), PRISM_ALIGNOF(pm_constant_path_and_write_node_t));
+
+    *node = (pm_constant_path_and_write_node_t) {
+        .base = { .type = PM_CONSTANT_PATH_AND_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .target = target,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantPathNode node.
+ */
+pm_constant_path_node_t *
+pm_constant_path_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *parent, pm_constant_id_t name, pm_location_t delimiter_loc, pm_location_t name_loc) {
+    pm_constant_path_node_t *node = (pm_constant_path_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_path_node_t), PRISM_ALIGNOF(pm_constant_path_node_t));
+
+    *node = (pm_constant_path_node_t) {
+        .base = { .type = PM_CONSTANT_PATH_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .parent = parent,
+        .name = name,
+        .delimiter_loc = delimiter_loc,
+        .name_loc = name_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantPathOperatorWriteNode node.
+ */
+pm_constant_path_operator_write_node_t *
+pm_constant_path_operator_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_constant_path_node *target, pm_location_t binary_operator_loc, struct pm_node *value, pm_constant_id_t binary_operator) {
+    pm_constant_path_operator_write_node_t *node = (pm_constant_path_operator_write_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_path_operator_write_node_t), PRISM_ALIGNOF(pm_constant_path_operator_write_node_t));
+
+    *node = (pm_constant_path_operator_write_node_t) {
+        .base = { .type = PM_CONSTANT_PATH_OPERATOR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .target = target,
+        .binary_operator_loc = binary_operator_loc,
+        .value = value,
+        .binary_operator = binary_operator
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantPathOrWriteNode node.
+ */
+pm_constant_path_or_write_node_t *
+pm_constant_path_or_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_constant_path_node *target, pm_location_t operator_loc, struct pm_node *value) {
+    pm_constant_path_or_write_node_t *node = (pm_constant_path_or_write_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_path_or_write_node_t), PRISM_ALIGNOF(pm_constant_path_or_write_node_t));
+
+    *node = (pm_constant_path_or_write_node_t) {
+        .base = { .type = PM_CONSTANT_PATH_OR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .target = target,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantPathTargetNode node.
+ */
+pm_constant_path_target_node_t *
+pm_constant_path_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *parent, pm_constant_id_t name, pm_location_t delimiter_loc, pm_location_t name_loc) {
+    pm_constant_path_target_node_t *node = (pm_constant_path_target_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_path_target_node_t), PRISM_ALIGNOF(pm_constant_path_target_node_t));
+
+    *node = (pm_constant_path_target_node_t) {
+        .base = { .type = PM_CONSTANT_PATH_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .parent = parent,
+        .name = name,
+        .delimiter_loc = delimiter_loc,
+        .name_loc = name_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantPathWriteNode node.
+ */
+pm_constant_path_write_node_t *
+pm_constant_path_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_constant_path_node *target, pm_location_t operator_loc, struct pm_node *value) {
+    pm_constant_path_write_node_t *node = (pm_constant_path_write_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_path_write_node_t), PRISM_ALIGNOF(pm_constant_path_write_node_t));
+
+    *node = (pm_constant_path_write_node_t) {
+        .base = { .type = PM_CONSTANT_PATH_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .target = target,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantReadNode node.
+ */
+pm_constant_read_node_t *
+pm_constant_read_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_constant_read_node_t *node = (pm_constant_read_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_read_node_t), PRISM_ALIGNOF(pm_constant_read_node_t));
+
+    *node = (pm_constant_read_node_t) {
+        .base = { .type = PM_CONSTANT_READ_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantTargetNode node.
+ */
+pm_constant_target_node_t *
+pm_constant_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_constant_target_node_t *node = (pm_constant_target_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_target_node_t), PRISM_ALIGNOF(pm_constant_target_node_t));
+
+    *node = (pm_constant_target_node_t) {
+        .base = { .type = PM_CONSTANT_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ConstantWriteNode node.
+ */
+pm_constant_write_node_t *
+pm_constant_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, struct pm_node *value, pm_location_t operator_loc) {
+    pm_constant_write_node_t *node = (pm_constant_write_node_t *) pm_arena_alloc(arena, sizeof(pm_constant_write_node_t), PRISM_ALIGNOF(pm_constant_write_node_t));
+
+    *node = (pm_constant_write_node_t) {
+        .base = { .type = PM_CONSTANT_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .value = value,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new DefNode node.
+ */
+pm_def_node_t *
+pm_def_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, struct pm_node *receiver, struct pm_parameters_node *parameters, struct pm_node *body, pm_constant_id_list_t locals, pm_location_t def_keyword_loc, pm_location_t operator_loc, pm_location_t lparen_loc, pm_location_t rparen_loc, pm_location_t equal_loc, pm_location_t end_keyword_loc) {
+    pm_def_node_t *node = (pm_def_node_t *) pm_arena_alloc(arena, sizeof(pm_def_node_t), PRISM_ALIGNOF(pm_def_node_t));
+
+    *node = (pm_def_node_t) {
+        .base = { .type = PM_DEF_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .receiver = receiver,
+        .parameters = parameters,
+        .body = body,
+        .locals = locals,
+        .def_keyword_loc = def_keyword_loc,
+        .operator_loc = operator_loc,
+        .lparen_loc = lparen_loc,
+        .rparen_loc = rparen_loc,
+        .equal_loc = equal_loc,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new DefinedNode node.
+ */
+pm_defined_node_t *
+pm_defined_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t lparen_loc, struct pm_node *value, pm_location_t rparen_loc, pm_location_t keyword_loc) {
+    pm_defined_node_t *node = (pm_defined_node_t *) pm_arena_alloc(arena, sizeof(pm_defined_node_t), PRISM_ALIGNOF(pm_defined_node_t));
+
+    *node = (pm_defined_node_t) {
+        .base = { .type = PM_DEFINED_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .lparen_loc = lparen_loc,
+        .value = value,
+        .rparen_loc = rparen_loc,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ElseNode node.
+ */
+pm_else_node_t *
+pm_else_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t else_keyword_loc, struct pm_statements_node *statements, pm_location_t end_keyword_loc) {
+    pm_else_node_t *node = (pm_else_node_t *) pm_arena_alloc(arena, sizeof(pm_else_node_t), PRISM_ALIGNOF(pm_else_node_t));
+
+    *node = (pm_else_node_t) {
+        .base = { .type = PM_ELSE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .else_keyword_loc = else_keyword_loc,
+        .statements = statements,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new EmbeddedStatementsNode node.
+ */
+pm_embedded_statements_node_t *
+pm_embedded_statements_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, struct pm_statements_node *statements, pm_location_t closing_loc) {
+    pm_embedded_statements_node_t *node = (pm_embedded_statements_node_t *) pm_arena_alloc(arena, sizeof(pm_embedded_statements_node_t), PRISM_ALIGNOF(pm_embedded_statements_node_t));
+
+    *node = (pm_embedded_statements_node_t) {
+        .base = { .type = PM_EMBEDDED_STATEMENTS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .statements = statements,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new EmbeddedVariableNode node.
+ */
+pm_embedded_variable_node_t *
+pm_embedded_variable_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t operator_loc, struct pm_node *variable) {
+    pm_embedded_variable_node_t *node = (pm_embedded_variable_node_t *) pm_arena_alloc(arena, sizeof(pm_embedded_variable_node_t), PRISM_ALIGNOF(pm_embedded_variable_node_t));
+
+    *node = (pm_embedded_variable_node_t) {
+        .base = { .type = PM_EMBEDDED_VARIABLE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .operator_loc = operator_loc,
+        .variable = variable
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new EnsureNode node.
+ */
+pm_ensure_node_t *
+pm_ensure_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t ensure_keyword_loc, struct pm_statements_node *statements, pm_location_t end_keyword_loc) {
+    pm_ensure_node_t *node = (pm_ensure_node_t *) pm_arena_alloc(arena, sizeof(pm_ensure_node_t), PRISM_ALIGNOF(pm_ensure_node_t));
+
+    *node = (pm_ensure_node_t) {
+        .base = { .type = PM_ENSURE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .ensure_keyword_loc = ensure_keyword_loc,
+        .statements = statements,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ErrorRecoveryNode node.
+ */
+pm_error_recovery_node_t *
+pm_error_recovery_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *unexpected) {
+    pm_error_recovery_node_t *node = (pm_error_recovery_node_t *) pm_arena_alloc(arena, sizeof(pm_error_recovery_node_t), PRISM_ALIGNOF(pm_error_recovery_node_t));
+
+    *node = (pm_error_recovery_node_t) {
+        .base = { .type = PM_ERROR_RECOVERY_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .unexpected = unexpected
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new FalseNode node.
+ */
+pm_false_node_t *
+pm_false_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_false_node_t *node = (pm_false_node_t *) pm_arena_alloc(arena, sizeof(pm_false_node_t), PRISM_ALIGNOF(pm_false_node_t));
+
+    *node = (pm_false_node_t) {
+        .base = { .type = PM_FALSE_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new FindPatternNode node.
+ */
+pm_find_pattern_node_t *
+pm_find_pattern_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *constant, struct pm_splat_node *left, pm_node_list_t requireds, struct pm_splat_node *right, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_find_pattern_node_t *node = (pm_find_pattern_node_t *) pm_arena_alloc(arena, sizeof(pm_find_pattern_node_t), PRISM_ALIGNOF(pm_find_pattern_node_t));
+
+    *node = (pm_find_pattern_node_t) {
+        .base = { .type = PM_FIND_PATTERN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .constant = constant,
+        .left = left,
+        .requireds = requireds,
+        .right = right,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new FlipFlopNode node.
+ */
+pm_flip_flop_node_t *
+pm_flip_flop_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *left, struct pm_node *right, pm_location_t operator_loc) {
+    pm_flip_flop_node_t *node = (pm_flip_flop_node_t *) pm_arena_alloc(arena, sizeof(pm_flip_flop_node_t), PRISM_ALIGNOF(pm_flip_flop_node_t));
+
+    *node = (pm_flip_flop_node_t) {
+        .base = { .type = PM_FLIP_FLOP_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .left = left,
+        .right = right,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new FloatNode node.
+ */
+pm_float_node_t *
+pm_float_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, double value) {
+    pm_float_node_t *node = (pm_float_node_t *) pm_arena_alloc(arena, sizeof(pm_float_node_t), PRISM_ALIGNOF(pm_float_node_t));
+
+    *node = (pm_float_node_t) {
+        .base = { .type = PM_FLOAT_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ForNode node.
+ */
+pm_for_node_t *
+pm_for_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *index, struct pm_node *collection, struct pm_statements_node *statements, pm_location_t for_keyword_loc, pm_location_t in_keyword_loc, pm_location_t do_keyword_loc, pm_location_t end_keyword_loc) {
+    pm_for_node_t *node = (pm_for_node_t *) pm_arena_alloc(arena, sizeof(pm_for_node_t), PRISM_ALIGNOF(pm_for_node_t));
+
+    *node = (pm_for_node_t) {
+        .base = { .type = PM_FOR_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .index = index,
+        .collection = collection,
+        .statements = statements,
+        .for_keyword_loc = for_keyword_loc,
+        .in_keyword_loc = in_keyword_loc,
+        .do_keyword_loc = do_keyword_loc,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ForwardingArgumentsNode node.
+ */
+pm_forwarding_arguments_node_t *
+pm_forwarding_arguments_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_forwarding_arguments_node_t *node = (pm_forwarding_arguments_node_t *) pm_arena_alloc(arena, sizeof(pm_forwarding_arguments_node_t), PRISM_ALIGNOF(pm_forwarding_arguments_node_t));
+
+    *node = (pm_forwarding_arguments_node_t) {
+        .base = { .type = PM_FORWARDING_ARGUMENTS_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ForwardingParameterNode node.
+ */
+pm_forwarding_parameter_node_t *
+pm_forwarding_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_forwarding_parameter_node_t *node = (pm_forwarding_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_forwarding_parameter_node_t), PRISM_ALIGNOF(pm_forwarding_parameter_node_t));
+
+    *node = (pm_forwarding_parameter_node_t) {
+        .base = { .type = PM_FORWARDING_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ForwardingSuperNode node.
+ */
+pm_forwarding_super_node_t *
+pm_forwarding_super_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t keyword_loc, struct pm_block_node *block) {
+    pm_forwarding_super_node_t *node = (pm_forwarding_super_node_t *) pm_arena_alloc(arena, sizeof(pm_forwarding_super_node_t), PRISM_ALIGNOF(pm_forwarding_super_node_t));
+
+    *node = (pm_forwarding_super_node_t) {
+        .base = { .type = PM_FORWARDING_SUPER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .keyword_loc = keyword_loc,
+        .block = block
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new GlobalVariableAndWriteNode node.
+ */
+pm_global_variable_and_write_node_t *
+pm_global_variable_and_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_global_variable_and_write_node_t *node = (pm_global_variable_and_write_node_t *) pm_arena_alloc(arena, sizeof(pm_global_variable_and_write_node_t), PRISM_ALIGNOF(pm_global_variable_and_write_node_t));
+
+    *node = (pm_global_variable_and_write_node_t) {
+        .base = { .type = PM_GLOBAL_VARIABLE_AND_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new GlobalVariableOperatorWriteNode node.
+ */
+pm_global_variable_operator_write_node_t *
+pm_global_variable_operator_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t binary_operator_loc, struct pm_node *value, pm_constant_id_t binary_operator) {
+    pm_global_variable_operator_write_node_t *node = (pm_global_variable_operator_write_node_t *) pm_arena_alloc(arena, sizeof(pm_global_variable_operator_write_node_t), PRISM_ALIGNOF(pm_global_variable_operator_write_node_t));
+
+    *node = (pm_global_variable_operator_write_node_t) {
+        .base = { .type = PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .binary_operator_loc = binary_operator_loc,
+        .value = value,
+        .binary_operator = binary_operator
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new GlobalVariableOrWriteNode node.
+ */
+pm_global_variable_or_write_node_t *
+pm_global_variable_or_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_global_variable_or_write_node_t *node = (pm_global_variable_or_write_node_t *) pm_arena_alloc(arena, sizeof(pm_global_variable_or_write_node_t), PRISM_ALIGNOF(pm_global_variable_or_write_node_t));
+
+    *node = (pm_global_variable_or_write_node_t) {
+        .base = { .type = PM_GLOBAL_VARIABLE_OR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new GlobalVariableReadNode node.
+ */
+pm_global_variable_read_node_t *
+pm_global_variable_read_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_global_variable_read_node_t *node = (pm_global_variable_read_node_t *) pm_arena_alloc(arena, sizeof(pm_global_variable_read_node_t), PRISM_ALIGNOF(pm_global_variable_read_node_t));
+
+    *node = (pm_global_variable_read_node_t) {
+        .base = { .type = PM_GLOBAL_VARIABLE_READ_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new GlobalVariableTargetNode node.
+ */
+pm_global_variable_target_node_t *
+pm_global_variable_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_global_variable_target_node_t *node = (pm_global_variable_target_node_t *) pm_arena_alloc(arena, sizeof(pm_global_variable_target_node_t), PRISM_ALIGNOF(pm_global_variable_target_node_t));
+
+    *node = (pm_global_variable_target_node_t) {
+        .base = { .type = PM_GLOBAL_VARIABLE_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new GlobalVariableWriteNode node.
+ */
+pm_global_variable_write_node_t *
+pm_global_variable_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, struct pm_node *value, pm_location_t operator_loc) {
+    pm_global_variable_write_node_t *node = (pm_global_variable_write_node_t *) pm_arena_alloc(arena, sizeof(pm_global_variable_write_node_t), PRISM_ALIGNOF(pm_global_variable_write_node_t));
+
+    *node = (pm_global_variable_write_node_t) {
+        .base = { .type = PM_GLOBAL_VARIABLE_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .value = value,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new HashNode node.
+ */
+pm_hash_node_t *
+pm_hash_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_node_list_t elements, pm_location_t closing_loc) {
+    pm_hash_node_t *node = (pm_hash_node_t *) pm_arena_alloc(arena, sizeof(pm_hash_node_t), PRISM_ALIGNOF(pm_hash_node_t));
+
+    *node = (pm_hash_node_t) {
+        .base = { .type = PM_HASH_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .elements = elements,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new HashPatternNode node.
+ */
+pm_hash_pattern_node_t *
+pm_hash_pattern_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *constant, pm_node_list_t elements, struct pm_node *rest, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_hash_pattern_node_t *node = (pm_hash_pattern_node_t *) pm_arena_alloc(arena, sizeof(pm_hash_pattern_node_t), PRISM_ALIGNOF(pm_hash_pattern_node_t));
+
+    *node = (pm_hash_pattern_node_t) {
+        .base = { .type = PM_HASH_PATTERN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .constant = constant,
+        .elements = elements,
+        .rest = rest,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new IfNode node.
+ */
+pm_if_node_t *
+pm_if_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t if_keyword_loc, struct pm_node *predicate, pm_location_t then_keyword_loc, struct pm_statements_node *statements, struct pm_node *subsequent, pm_location_t end_keyword_loc) {
+    pm_if_node_t *node = (pm_if_node_t *) pm_arena_alloc(arena, sizeof(pm_if_node_t), PRISM_ALIGNOF(pm_if_node_t));
+
+    *node = (pm_if_node_t) {
+        .base = { .type = PM_IF_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .if_keyword_loc = if_keyword_loc,
+        .predicate = predicate,
+        .then_keyword_loc = then_keyword_loc,
+        .statements = statements,
+        .subsequent = subsequent,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ImaginaryNode node.
+ */
+pm_imaginary_node_t *
+pm_imaginary_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *numeric) {
+    pm_imaginary_node_t *node = (pm_imaginary_node_t *) pm_arena_alloc(arena, sizeof(pm_imaginary_node_t), PRISM_ALIGNOF(pm_imaginary_node_t));
+
+    *node = (pm_imaginary_node_t) {
+        .base = { .type = PM_IMAGINARY_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .numeric = numeric
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ImplicitNode node.
+ */
+pm_implicit_node_t *
+pm_implicit_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *value) {
+    pm_implicit_node_t *node = (pm_implicit_node_t *) pm_arena_alloc(arena, sizeof(pm_implicit_node_t), PRISM_ALIGNOF(pm_implicit_node_t));
+
+    *node = (pm_implicit_node_t) {
+        .base = { .type = PM_IMPLICIT_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ImplicitRestNode node.
+ */
+pm_implicit_rest_node_t *
+pm_implicit_rest_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_implicit_rest_node_t *node = (pm_implicit_rest_node_t *) pm_arena_alloc(arena, sizeof(pm_implicit_rest_node_t), PRISM_ALIGNOF(pm_implicit_rest_node_t));
+
+    *node = (pm_implicit_rest_node_t) {
+        .base = { .type = PM_IMPLICIT_REST_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InNode node.
+ */
+pm_in_node_t *
+pm_in_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *pattern, struct pm_statements_node *statements, pm_location_t in_keyword_loc, pm_location_t then_keyword_loc) {
+    pm_in_node_t *node = (pm_in_node_t *) pm_arena_alloc(arena, sizeof(pm_in_node_t), PRISM_ALIGNOF(pm_in_node_t));
+
+    *node = (pm_in_node_t) {
+        .base = { .type = PM_IN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .pattern = pattern,
+        .statements = statements,
+        .in_keyword_loc = in_keyword_loc,
+        .then_keyword_loc = then_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new IndexAndWriteNode node.
+ */
+pm_index_and_write_node_t *
+pm_index_and_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t call_operator_loc, pm_location_t opening_loc, struct pm_arguments_node *arguments, pm_location_t closing_loc, struct pm_block_argument_node *block, pm_location_t operator_loc, struct pm_node *value) {
+    pm_index_and_write_node_t *node = (pm_index_and_write_node_t *) pm_arena_alloc(arena, sizeof(pm_index_and_write_node_t), PRISM_ALIGNOF(pm_index_and_write_node_t));
+
+    *node = (pm_index_and_write_node_t) {
+        .base = { .type = PM_INDEX_AND_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .call_operator_loc = call_operator_loc,
+        .opening_loc = opening_loc,
+        .arguments = arguments,
+        .closing_loc = closing_loc,
+        .block = block,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new IndexOperatorWriteNode node.
+ */
+pm_index_operator_write_node_t *
+pm_index_operator_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t call_operator_loc, pm_location_t opening_loc, struct pm_arguments_node *arguments, pm_location_t closing_loc, struct pm_block_argument_node *block, pm_constant_id_t binary_operator, pm_location_t binary_operator_loc, struct pm_node *value) {
+    pm_index_operator_write_node_t *node = (pm_index_operator_write_node_t *) pm_arena_alloc(arena, sizeof(pm_index_operator_write_node_t), PRISM_ALIGNOF(pm_index_operator_write_node_t));
+
+    *node = (pm_index_operator_write_node_t) {
+        .base = { .type = PM_INDEX_OPERATOR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .call_operator_loc = call_operator_loc,
+        .opening_loc = opening_loc,
+        .arguments = arguments,
+        .closing_loc = closing_loc,
+        .block = block,
+        .binary_operator = binary_operator,
+        .binary_operator_loc = binary_operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new IndexOrWriteNode node.
+ */
+pm_index_or_write_node_t *
+pm_index_or_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t call_operator_loc, pm_location_t opening_loc, struct pm_arguments_node *arguments, pm_location_t closing_loc, struct pm_block_argument_node *block, pm_location_t operator_loc, struct pm_node *value) {
+    pm_index_or_write_node_t *node = (pm_index_or_write_node_t *) pm_arena_alloc(arena, sizeof(pm_index_or_write_node_t), PRISM_ALIGNOF(pm_index_or_write_node_t));
+
+    *node = (pm_index_or_write_node_t) {
+        .base = { .type = PM_INDEX_OR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .call_operator_loc = call_operator_loc,
+        .opening_loc = opening_loc,
+        .arguments = arguments,
+        .closing_loc = closing_loc,
+        .block = block,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new IndexTargetNode node.
+ */
+pm_index_target_node_t *
+pm_index_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *receiver, pm_location_t opening_loc, struct pm_arguments_node *arguments, pm_location_t closing_loc, struct pm_block_argument_node *block) {
+    pm_index_target_node_t *node = (pm_index_target_node_t *) pm_arena_alloc(arena, sizeof(pm_index_target_node_t), PRISM_ALIGNOF(pm_index_target_node_t));
+
+    *node = (pm_index_target_node_t) {
+        .base = { .type = PM_INDEX_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .receiver = receiver,
+        .opening_loc = opening_loc,
+        .arguments = arguments,
+        .closing_loc = closing_loc,
+        .block = block
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InstanceVariableAndWriteNode node.
+ */
+pm_instance_variable_and_write_node_t *
+pm_instance_variable_and_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_instance_variable_and_write_node_t *node = (pm_instance_variable_and_write_node_t *) pm_arena_alloc(arena, sizeof(pm_instance_variable_and_write_node_t), PRISM_ALIGNOF(pm_instance_variable_and_write_node_t));
+
+    *node = (pm_instance_variable_and_write_node_t) {
+        .base = { .type = PM_INSTANCE_VARIABLE_AND_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InstanceVariableOperatorWriteNode node.
+ */
+pm_instance_variable_operator_write_node_t *
+pm_instance_variable_operator_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t binary_operator_loc, struct pm_node *value, pm_constant_id_t binary_operator) {
+    pm_instance_variable_operator_write_node_t *node = (pm_instance_variable_operator_write_node_t *) pm_arena_alloc(arena, sizeof(pm_instance_variable_operator_write_node_t), PRISM_ALIGNOF(pm_instance_variable_operator_write_node_t));
+
+    *node = (pm_instance_variable_operator_write_node_t) {
+        .base = { .type = PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .binary_operator_loc = binary_operator_loc,
+        .value = value,
+        .binary_operator = binary_operator
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InstanceVariableOrWriteNode node.
+ */
+pm_instance_variable_or_write_node_t *
+pm_instance_variable_or_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_instance_variable_or_write_node_t *node = (pm_instance_variable_or_write_node_t *) pm_arena_alloc(arena, sizeof(pm_instance_variable_or_write_node_t), PRISM_ALIGNOF(pm_instance_variable_or_write_node_t));
+
+    *node = (pm_instance_variable_or_write_node_t) {
+        .base = { .type = PM_INSTANCE_VARIABLE_OR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InstanceVariableReadNode node.
+ */
+pm_instance_variable_read_node_t *
+pm_instance_variable_read_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_instance_variable_read_node_t *node = (pm_instance_variable_read_node_t *) pm_arena_alloc(arena, sizeof(pm_instance_variable_read_node_t), PRISM_ALIGNOF(pm_instance_variable_read_node_t));
+
+    *node = (pm_instance_variable_read_node_t) {
+        .base = { .type = PM_INSTANCE_VARIABLE_READ_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InstanceVariableTargetNode node.
+ */
+pm_instance_variable_target_node_t *
+pm_instance_variable_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_instance_variable_target_node_t *node = (pm_instance_variable_target_node_t *) pm_arena_alloc(arena, sizeof(pm_instance_variable_target_node_t), PRISM_ALIGNOF(pm_instance_variable_target_node_t));
+
+    *node = (pm_instance_variable_target_node_t) {
+        .base = { .type = PM_INSTANCE_VARIABLE_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InstanceVariableWriteNode node.
+ */
+pm_instance_variable_write_node_t *
+pm_instance_variable_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, struct pm_node *value, pm_location_t operator_loc) {
+    pm_instance_variable_write_node_t *node = (pm_instance_variable_write_node_t *) pm_arena_alloc(arena, sizeof(pm_instance_variable_write_node_t), PRISM_ALIGNOF(pm_instance_variable_write_node_t));
+
+    *node = (pm_instance_variable_write_node_t) {
+        .base = { .type = PM_INSTANCE_VARIABLE_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .value = value,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new IntegerNode node.
+ */
+pm_integer_node_t *
+pm_integer_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_integer_t value) {
+    pm_integer_node_t *node = (pm_integer_node_t *) pm_arena_alloc(arena, sizeof(pm_integer_node_t), PRISM_ALIGNOF(pm_integer_node_t));
+
+    *node = (pm_integer_node_t) {
+        .base = { .type = PM_INTEGER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InterpolatedMatchLastLineNode node.
+ */
+pm_interpolated_match_last_line_node_t *
+pm_interpolated_match_last_line_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_node_list_t parts, pm_location_t closing_loc) {
+    pm_interpolated_match_last_line_node_t *node = (pm_interpolated_match_last_line_node_t *) pm_arena_alloc(arena, sizeof(pm_interpolated_match_last_line_node_t), PRISM_ALIGNOF(pm_interpolated_match_last_line_node_t));
+
+    *node = (pm_interpolated_match_last_line_node_t) {
+        .base = { .type = PM_INTERPOLATED_MATCH_LAST_LINE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .parts = parts,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InterpolatedRegularExpressionNode node.
+ */
+pm_interpolated_regular_expression_node_t *
+pm_interpolated_regular_expression_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_node_list_t parts, pm_location_t closing_loc) {
+    pm_interpolated_regular_expression_node_t *node = (pm_interpolated_regular_expression_node_t *) pm_arena_alloc(arena, sizeof(pm_interpolated_regular_expression_node_t), PRISM_ALIGNOF(pm_interpolated_regular_expression_node_t));
+
+    *node = (pm_interpolated_regular_expression_node_t) {
+        .base = { .type = PM_INTERPOLATED_REGULAR_EXPRESSION_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .parts = parts,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InterpolatedStringNode node.
+ */
+pm_interpolated_string_node_t *
+pm_interpolated_string_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_node_list_t parts, pm_location_t closing_loc) {
+    pm_interpolated_string_node_t *node = (pm_interpolated_string_node_t *) pm_arena_alloc(arena, sizeof(pm_interpolated_string_node_t), PRISM_ALIGNOF(pm_interpolated_string_node_t));
+
+    *node = (pm_interpolated_string_node_t) {
+        .base = { .type = PM_INTERPOLATED_STRING_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .parts = parts,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InterpolatedSymbolNode node.
+ */
+pm_interpolated_symbol_node_t *
+pm_interpolated_symbol_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_node_list_t parts, pm_location_t closing_loc) {
+    pm_interpolated_symbol_node_t *node = (pm_interpolated_symbol_node_t *) pm_arena_alloc(arena, sizeof(pm_interpolated_symbol_node_t), PRISM_ALIGNOF(pm_interpolated_symbol_node_t));
+
+    *node = (pm_interpolated_symbol_node_t) {
+        .base = { .type = PM_INTERPOLATED_SYMBOL_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .parts = parts,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new InterpolatedXStringNode node.
+ */
+pm_interpolated_x_string_node_t *
+pm_interpolated_x_string_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_node_list_t parts, pm_location_t closing_loc) {
+    pm_interpolated_x_string_node_t *node = (pm_interpolated_x_string_node_t *) pm_arena_alloc(arena, sizeof(pm_interpolated_x_string_node_t), PRISM_ALIGNOF(pm_interpolated_x_string_node_t));
+
+    *node = (pm_interpolated_x_string_node_t) {
+        .base = { .type = PM_INTERPOLATED_X_STRING_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .parts = parts,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ItLocalVariableReadNode node.
+ */
+pm_it_local_variable_read_node_t *
+pm_it_local_variable_read_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_it_local_variable_read_node_t *node = (pm_it_local_variable_read_node_t *) pm_arena_alloc(arena, sizeof(pm_it_local_variable_read_node_t), PRISM_ALIGNOF(pm_it_local_variable_read_node_t));
+
+    *node = (pm_it_local_variable_read_node_t) {
+        .base = { .type = PM_IT_LOCAL_VARIABLE_READ_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ItParametersNode node.
+ */
+pm_it_parameters_node_t *
+pm_it_parameters_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_it_parameters_node_t *node = (pm_it_parameters_node_t *) pm_arena_alloc(arena, sizeof(pm_it_parameters_node_t), PRISM_ALIGNOF(pm_it_parameters_node_t));
+
+    *node = (pm_it_parameters_node_t) {
+        .base = { .type = PM_IT_PARAMETERS_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new KeywordHashNode node.
+ */
+pm_keyword_hash_node_t *
+pm_keyword_hash_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_node_list_t elements) {
+    pm_keyword_hash_node_t *node = (pm_keyword_hash_node_t *) pm_arena_alloc(arena, sizeof(pm_keyword_hash_node_t), PRISM_ALIGNOF(pm_keyword_hash_node_t));
+
+    *node = (pm_keyword_hash_node_t) {
+        .base = { .type = PM_KEYWORD_HASH_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .elements = elements
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new KeywordRestParameterNode node.
+ */
+pm_keyword_rest_parameter_node_t *
+pm_keyword_rest_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc) {
+    pm_keyword_rest_parameter_node_t *node = (pm_keyword_rest_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_keyword_rest_parameter_node_t), PRISM_ALIGNOF(pm_keyword_rest_parameter_node_t));
+
+    *node = (pm_keyword_rest_parameter_node_t) {
+        .base = { .type = PM_KEYWORD_REST_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new LambdaNode node.
+ */
+pm_lambda_node_t *
+pm_lambda_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_list_t locals, pm_location_t operator_loc, pm_location_t opening_loc, pm_location_t closing_loc, struct pm_node *parameters, struct pm_node *body) {
+    pm_lambda_node_t *node = (pm_lambda_node_t *) pm_arena_alloc(arena, sizeof(pm_lambda_node_t), PRISM_ALIGNOF(pm_lambda_node_t));
+
+    *node = (pm_lambda_node_t) {
+        .base = { .type = PM_LAMBDA_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .locals = locals,
+        .operator_loc = operator_loc,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc,
+        .parameters = parameters,
+        .body = body
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new LocalVariableAndWriteNode node.
+ */
+pm_local_variable_and_write_node_t *
+pm_local_variable_and_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value, pm_constant_id_t name, uint32_t depth) {
+    pm_local_variable_and_write_node_t *node = (pm_local_variable_and_write_node_t *) pm_arena_alloc(arena, sizeof(pm_local_variable_and_write_node_t), PRISM_ALIGNOF(pm_local_variable_and_write_node_t));
+
+    *node = (pm_local_variable_and_write_node_t) {
+        .base = { .type = PM_LOCAL_VARIABLE_AND_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value,
+        .name = name,
+        .depth = depth
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new LocalVariableOperatorWriteNode node.
+ */
+pm_local_variable_operator_write_node_t *
+pm_local_variable_operator_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t name_loc, pm_location_t binary_operator_loc, struct pm_node *value, pm_constant_id_t name, pm_constant_id_t binary_operator, uint32_t depth) {
+    pm_local_variable_operator_write_node_t *node = (pm_local_variable_operator_write_node_t *) pm_arena_alloc(arena, sizeof(pm_local_variable_operator_write_node_t), PRISM_ALIGNOF(pm_local_variable_operator_write_node_t));
+
+    *node = (pm_local_variable_operator_write_node_t) {
+        .base = { .type = PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name_loc = name_loc,
+        .binary_operator_loc = binary_operator_loc,
+        .value = value,
+        .name = name,
+        .binary_operator = binary_operator,
+        .depth = depth
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new LocalVariableOrWriteNode node.
+ */
+pm_local_variable_or_write_node_t *
+pm_local_variable_or_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value, pm_constant_id_t name, uint32_t depth) {
+    pm_local_variable_or_write_node_t *node = (pm_local_variable_or_write_node_t *) pm_arena_alloc(arena, sizeof(pm_local_variable_or_write_node_t), PRISM_ALIGNOF(pm_local_variable_or_write_node_t));
+
+    *node = (pm_local_variable_or_write_node_t) {
+        .base = { .type = PM_LOCAL_VARIABLE_OR_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value,
+        .name = name,
+        .depth = depth
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new LocalVariableReadNode node.
+ */
+pm_local_variable_read_node_t *
+pm_local_variable_read_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, uint32_t depth) {
+    pm_local_variable_read_node_t *node = (pm_local_variable_read_node_t *) pm_arena_alloc(arena, sizeof(pm_local_variable_read_node_t), PRISM_ALIGNOF(pm_local_variable_read_node_t));
+
+    *node = (pm_local_variable_read_node_t) {
+        .base = { .type = PM_LOCAL_VARIABLE_READ_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .depth = depth
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new LocalVariableTargetNode node.
+ */
+pm_local_variable_target_node_t *
+pm_local_variable_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, uint32_t depth) {
+    pm_local_variable_target_node_t *node = (pm_local_variable_target_node_t *) pm_arena_alloc(arena, sizeof(pm_local_variable_target_node_t), PRISM_ALIGNOF(pm_local_variable_target_node_t));
+
+    *node = (pm_local_variable_target_node_t) {
+        .base = { .type = PM_LOCAL_VARIABLE_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .depth = depth
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new LocalVariableWriteNode node.
+ */
+pm_local_variable_write_node_t *
+pm_local_variable_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, uint32_t depth, pm_location_t name_loc, struct pm_node *value, pm_location_t operator_loc) {
+    pm_local_variable_write_node_t *node = (pm_local_variable_write_node_t *) pm_arena_alloc(arena, sizeof(pm_local_variable_write_node_t), PRISM_ALIGNOF(pm_local_variable_write_node_t));
+
+    *node = (pm_local_variable_write_node_t) {
+        .base = { .type = PM_LOCAL_VARIABLE_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .depth = depth,
+        .name_loc = name_loc,
+        .value = value,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new MatchLastLineNode node.
+ */
+pm_match_last_line_node_t *
+pm_match_last_line_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_location_t content_loc, pm_location_t closing_loc, pm_string_t unescaped) {
+    pm_match_last_line_node_t *node = (pm_match_last_line_node_t *) pm_arena_alloc(arena, sizeof(pm_match_last_line_node_t), PRISM_ALIGNOF(pm_match_last_line_node_t));
+
+    *node = (pm_match_last_line_node_t) {
+        .base = { .type = PM_MATCH_LAST_LINE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .content_loc = content_loc,
+        .closing_loc = closing_loc,
+        .unescaped = unescaped
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new MatchPredicateNode node.
+ */
+pm_match_predicate_node_t *
+pm_match_predicate_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *value, struct pm_node *pattern, pm_location_t keyword_loc) {
+    pm_match_predicate_node_t *node = (pm_match_predicate_node_t *) pm_arena_alloc(arena, sizeof(pm_match_predicate_node_t), PRISM_ALIGNOF(pm_match_predicate_node_t));
+
+    *node = (pm_match_predicate_node_t) {
+        .base = { .type = PM_MATCH_PREDICATE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .value = value,
+        .pattern = pattern,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new MatchRequiredNode node.
+ */
+pm_match_required_node_t *
+pm_match_required_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *value, struct pm_node *pattern, pm_location_t operator_loc) {
+    pm_match_required_node_t *node = (pm_match_required_node_t *) pm_arena_alloc(arena, sizeof(pm_match_required_node_t), PRISM_ALIGNOF(pm_match_required_node_t));
+
+    *node = (pm_match_required_node_t) {
+        .base = { .type = PM_MATCH_REQUIRED_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .value = value,
+        .pattern = pattern,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new MatchWriteNode node.
+ */
+pm_match_write_node_t *
+pm_match_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_call_node *call, pm_node_list_t targets) {
+    pm_match_write_node_t *node = (pm_match_write_node_t *) pm_arena_alloc(arena, sizeof(pm_match_write_node_t), PRISM_ALIGNOF(pm_match_write_node_t));
+
+    *node = (pm_match_write_node_t) {
+        .base = { .type = PM_MATCH_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .call = call,
+        .targets = targets
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ModuleNode node.
+ */
+pm_module_node_t *
+pm_module_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_list_t locals, pm_location_t module_keyword_loc, struct pm_node *constant_path, struct pm_node *body, pm_location_t end_keyword_loc, pm_constant_id_t name) {
+    pm_module_node_t *node = (pm_module_node_t *) pm_arena_alloc(arena, sizeof(pm_module_node_t), PRISM_ALIGNOF(pm_module_node_t));
+
+    *node = (pm_module_node_t) {
+        .base = { .type = PM_MODULE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .locals = locals,
+        .module_keyword_loc = module_keyword_loc,
+        .constant_path = constant_path,
+        .body = body,
+        .end_keyword_loc = end_keyword_loc,
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new MultiTargetNode node.
+ */
+pm_multi_target_node_t *
+pm_multi_target_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_node_list_t lefts, struct pm_node *rest, pm_node_list_t rights, pm_location_t lparen_loc, pm_location_t rparen_loc) {
+    pm_multi_target_node_t *node = (pm_multi_target_node_t *) pm_arena_alloc(arena, sizeof(pm_multi_target_node_t), PRISM_ALIGNOF(pm_multi_target_node_t));
+
+    *node = (pm_multi_target_node_t) {
+        .base = { .type = PM_MULTI_TARGET_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .lefts = lefts,
+        .rest = rest,
+        .rights = rights,
+        .lparen_loc = lparen_loc,
+        .rparen_loc = rparen_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new MultiWriteNode node.
+ */
+pm_multi_write_node_t *
+pm_multi_write_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_node_list_t lefts, struct pm_node *rest, pm_node_list_t rights, pm_location_t lparen_loc, pm_location_t rparen_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_multi_write_node_t *node = (pm_multi_write_node_t *) pm_arena_alloc(arena, sizeof(pm_multi_write_node_t), PRISM_ALIGNOF(pm_multi_write_node_t));
+
+    *node = (pm_multi_write_node_t) {
+        .base = { .type = PM_MULTI_WRITE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .lefts = lefts,
+        .rest = rest,
+        .rights = rights,
+        .lparen_loc = lparen_loc,
+        .rparen_loc = rparen_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new NextNode node.
+ */
+pm_next_node_t *
+pm_next_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_arguments_node *arguments, pm_location_t keyword_loc) {
+    pm_next_node_t *node = (pm_next_node_t *) pm_arena_alloc(arena, sizeof(pm_next_node_t), PRISM_ALIGNOF(pm_next_node_t));
+
+    *node = (pm_next_node_t) {
+        .base = { .type = PM_NEXT_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .arguments = arguments,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new NilNode node.
+ */
+pm_nil_node_t *
+pm_nil_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_nil_node_t *node = (pm_nil_node_t *) pm_arena_alloc(arena, sizeof(pm_nil_node_t), PRISM_ALIGNOF(pm_nil_node_t));
+
+    *node = (pm_nil_node_t) {
+        .base = { .type = PM_NIL_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new NoBlockParameterNode node.
+ */
+pm_no_block_parameter_node_t *
+pm_no_block_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t operator_loc, pm_location_t keyword_loc) {
+    pm_no_block_parameter_node_t *node = (pm_no_block_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_no_block_parameter_node_t), PRISM_ALIGNOF(pm_no_block_parameter_node_t));
+
+    *node = (pm_no_block_parameter_node_t) {
+        .base = { .type = PM_NO_BLOCK_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .operator_loc = operator_loc,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new NoKeywordsParameterNode node.
+ */
+pm_no_keywords_parameter_node_t *
+pm_no_keywords_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t operator_loc, pm_location_t keyword_loc) {
+    pm_no_keywords_parameter_node_t *node = (pm_no_keywords_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_no_keywords_parameter_node_t), PRISM_ALIGNOF(pm_no_keywords_parameter_node_t));
+
+    *node = (pm_no_keywords_parameter_node_t) {
+        .base = { .type = PM_NO_KEYWORDS_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .operator_loc = operator_loc,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new NumberedParametersNode node.
+ */
+pm_numbered_parameters_node_t *
+pm_numbered_parameters_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, uint8_t maximum) {
+    pm_numbered_parameters_node_t *node = (pm_numbered_parameters_node_t *) pm_arena_alloc(arena, sizeof(pm_numbered_parameters_node_t), PRISM_ALIGNOF(pm_numbered_parameters_node_t));
+
+    *node = (pm_numbered_parameters_node_t) {
+        .base = { .type = PM_NUMBERED_PARAMETERS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .maximum = maximum
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new NumberedReferenceReadNode node.
+ */
+pm_numbered_reference_read_node_t *
+pm_numbered_reference_read_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, uint32_t number) {
+    pm_numbered_reference_read_node_t *node = (pm_numbered_reference_read_node_t *) pm_arena_alloc(arena, sizeof(pm_numbered_reference_read_node_t), PRISM_ALIGNOF(pm_numbered_reference_read_node_t));
+
+    *node = (pm_numbered_reference_read_node_t) {
+        .base = { .type = PM_NUMBERED_REFERENCE_READ_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .number = number
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new OptionalKeywordParameterNode node.
+ */
+pm_optional_keyword_parameter_node_t *
+pm_optional_keyword_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, struct pm_node *value) {
+    pm_optional_keyword_parameter_node_t *node = (pm_optional_keyword_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_optional_keyword_parameter_node_t), PRISM_ALIGNOF(pm_optional_keyword_parameter_node_t));
+
+    *node = (pm_optional_keyword_parameter_node_t) {
+        .base = { .type = PM_OPTIONAL_KEYWORD_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new OptionalParameterNode node.
+ */
+pm_optional_parameter_node_t *
+pm_optional_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc, struct pm_node *value) {
+    pm_optional_parameter_node_t *node = (pm_optional_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_optional_parameter_node_t), PRISM_ALIGNOF(pm_optional_parameter_node_t));
+
+    *node = (pm_optional_parameter_node_t) {
+        .base = { .type = PM_OPTIONAL_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc,
+        .value = value
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new OrNode node.
+ */
+pm_or_node_t *
+pm_or_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *left, struct pm_node *right, pm_location_t operator_loc) {
+    pm_or_node_t *node = (pm_or_node_t *) pm_arena_alloc(arena, sizeof(pm_or_node_t), PRISM_ALIGNOF(pm_or_node_t));
+
+    *node = (pm_or_node_t) {
+        .base = { .type = PM_OR_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .left = left,
+        .right = right,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ParametersNode node.
+ */
+pm_parameters_node_t *
+pm_parameters_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_node_list_t requireds, pm_node_list_t optionals, struct pm_node *rest, pm_node_list_t posts, pm_node_list_t keywords, struct pm_node *keyword_rest, struct pm_node *block) {
+    pm_parameters_node_t *node = (pm_parameters_node_t *) pm_arena_alloc(arena, sizeof(pm_parameters_node_t), PRISM_ALIGNOF(pm_parameters_node_t));
+
+    *node = (pm_parameters_node_t) {
+        .base = { .type = PM_PARAMETERS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .requireds = requireds,
+        .optionals = optionals,
+        .rest = rest,
+        .posts = posts,
+        .keywords = keywords,
+        .keyword_rest = keyword_rest,
+        .block = block
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ParenthesesNode node.
+ */
+pm_parentheses_node_t *
+pm_parentheses_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *body, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_parentheses_node_t *node = (pm_parentheses_node_t *) pm_arena_alloc(arena, sizeof(pm_parentheses_node_t), PRISM_ALIGNOF(pm_parentheses_node_t));
+
+    *node = (pm_parentheses_node_t) {
+        .base = { .type = PM_PARENTHESES_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .body = body,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new PinnedExpressionNode node.
+ */
+pm_pinned_expression_node_t *
+pm_pinned_expression_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *expression, pm_location_t operator_loc, pm_location_t lparen_loc, pm_location_t rparen_loc) {
+    pm_pinned_expression_node_t *node = (pm_pinned_expression_node_t *) pm_arena_alloc(arena, sizeof(pm_pinned_expression_node_t), PRISM_ALIGNOF(pm_pinned_expression_node_t));
+
+    *node = (pm_pinned_expression_node_t) {
+        .base = { .type = PM_PINNED_EXPRESSION_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .expression = expression,
+        .operator_loc = operator_loc,
+        .lparen_loc = lparen_loc,
+        .rparen_loc = rparen_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new PinnedVariableNode node.
+ */
+pm_pinned_variable_node_t *
+pm_pinned_variable_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *variable, pm_location_t operator_loc) {
+    pm_pinned_variable_node_t *node = (pm_pinned_variable_node_t *) pm_arena_alloc(arena, sizeof(pm_pinned_variable_node_t), PRISM_ALIGNOF(pm_pinned_variable_node_t));
+
+    *node = (pm_pinned_variable_node_t) {
+        .base = { .type = PM_PINNED_VARIABLE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .variable = variable,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new PostExecutionNode node.
+ */
+pm_post_execution_node_t *
+pm_post_execution_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_statements_node *statements, pm_location_t keyword_loc, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_post_execution_node_t *node = (pm_post_execution_node_t *) pm_arena_alloc(arena, sizeof(pm_post_execution_node_t), PRISM_ALIGNOF(pm_post_execution_node_t));
+
+    *node = (pm_post_execution_node_t) {
+        .base = { .type = PM_POST_EXECUTION_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .statements = statements,
+        .keyword_loc = keyword_loc,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new PreExecutionNode node.
+ */
+pm_pre_execution_node_t *
+pm_pre_execution_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_statements_node *statements, pm_location_t keyword_loc, pm_location_t opening_loc, pm_location_t closing_loc) {
+    pm_pre_execution_node_t *node = (pm_pre_execution_node_t *) pm_arena_alloc(arena, sizeof(pm_pre_execution_node_t), PRISM_ALIGNOF(pm_pre_execution_node_t));
+
+    *node = (pm_pre_execution_node_t) {
+        .base = { .type = PM_PRE_EXECUTION_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .statements = statements,
+        .keyword_loc = keyword_loc,
+        .opening_loc = opening_loc,
+        .closing_loc = closing_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ProgramNode node.
+ */
+pm_program_node_t *
+pm_program_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_list_t locals, struct pm_statements_node *statements) {
+    pm_program_node_t *node = (pm_program_node_t *) pm_arena_alloc(arena, sizeof(pm_program_node_t), PRISM_ALIGNOF(pm_program_node_t));
+
+    *node = (pm_program_node_t) {
+        .base = { .type = PM_PROGRAM_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .locals = locals,
+        .statements = statements
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RangeNode node.
+ */
+pm_range_node_t *
+pm_range_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *left, struct pm_node *right, pm_location_t operator_loc) {
+    pm_range_node_t *node = (pm_range_node_t *) pm_arena_alloc(arena, sizeof(pm_range_node_t), PRISM_ALIGNOF(pm_range_node_t));
+
+    *node = (pm_range_node_t) {
+        .base = { .type = PM_RANGE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .left = left,
+        .right = right,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RationalNode node.
+ */
+pm_rational_node_t *
+pm_rational_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_integer_t numerator, pm_integer_t denominator) {
+    pm_rational_node_t *node = (pm_rational_node_t *) pm_arena_alloc(arena, sizeof(pm_rational_node_t), PRISM_ALIGNOF(pm_rational_node_t));
+
+    *node = (pm_rational_node_t) {
+        .base = { .type = PM_RATIONAL_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .numerator = numerator,
+        .denominator = denominator
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RedoNode node.
+ */
+pm_redo_node_t *
+pm_redo_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_redo_node_t *node = (pm_redo_node_t *) pm_arena_alloc(arena, sizeof(pm_redo_node_t), PRISM_ALIGNOF(pm_redo_node_t));
+
+    *node = (pm_redo_node_t) {
+        .base = { .type = PM_REDO_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RegularExpressionNode node.
+ */
+pm_regular_expression_node_t *
+pm_regular_expression_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_location_t content_loc, pm_location_t closing_loc, pm_string_t unescaped) {
+    pm_regular_expression_node_t *node = (pm_regular_expression_node_t *) pm_arena_alloc(arena, sizeof(pm_regular_expression_node_t), PRISM_ALIGNOF(pm_regular_expression_node_t));
+
+    *node = (pm_regular_expression_node_t) {
+        .base = { .type = PM_REGULAR_EXPRESSION_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .content_loc = content_loc,
+        .closing_loc = closing_loc,
+        .unescaped = unescaped
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RequiredKeywordParameterNode node.
+ */
+pm_required_keyword_parameter_node_t *
+pm_required_keyword_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc) {
+    pm_required_keyword_parameter_node_t *node = (pm_required_keyword_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_required_keyword_parameter_node_t), PRISM_ALIGNOF(pm_required_keyword_parameter_node_t));
+
+    *node = (pm_required_keyword_parameter_node_t) {
+        .base = { .type = PM_REQUIRED_KEYWORD_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RequiredParameterNode node.
+ */
+pm_required_parameter_node_t *
+pm_required_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name) {
+    pm_required_parameter_node_t *node = (pm_required_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_required_parameter_node_t), PRISM_ALIGNOF(pm_required_parameter_node_t));
+
+    *node = (pm_required_parameter_node_t) {
+        .base = { .type = PM_REQUIRED_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RescueModifierNode node.
+ */
+pm_rescue_modifier_node_t *
+pm_rescue_modifier_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *expression, pm_location_t keyword_loc, struct pm_node *rescue_expression) {
+    pm_rescue_modifier_node_t *node = (pm_rescue_modifier_node_t *) pm_arena_alloc(arena, sizeof(pm_rescue_modifier_node_t), PRISM_ALIGNOF(pm_rescue_modifier_node_t));
+
+    *node = (pm_rescue_modifier_node_t) {
+        .base = { .type = PM_RESCUE_MODIFIER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .expression = expression,
+        .keyword_loc = keyword_loc,
+        .rescue_expression = rescue_expression
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RescueNode node.
+ */
+pm_rescue_node_t *
+pm_rescue_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t keyword_loc, pm_node_list_t exceptions, pm_location_t operator_loc, struct pm_node *reference, pm_location_t then_keyword_loc, struct pm_statements_node *statements, struct pm_rescue_node *subsequent) {
+    pm_rescue_node_t *node = (pm_rescue_node_t *) pm_arena_alloc(arena, sizeof(pm_rescue_node_t), PRISM_ALIGNOF(pm_rescue_node_t));
+
+    *node = (pm_rescue_node_t) {
+        .base = { .type = PM_RESCUE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .keyword_loc = keyword_loc,
+        .exceptions = exceptions,
+        .operator_loc = operator_loc,
+        .reference = reference,
+        .then_keyword_loc = then_keyword_loc,
+        .statements = statements,
+        .subsequent = subsequent
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RestParameterNode node.
+ */
+pm_rest_parameter_node_t *
+pm_rest_parameter_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_t name, pm_location_t name_loc, pm_location_t operator_loc) {
+    pm_rest_parameter_node_t *node = (pm_rest_parameter_node_t *) pm_arena_alloc(arena, sizeof(pm_rest_parameter_node_t), PRISM_ALIGNOF(pm_rest_parameter_node_t));
+
+    *node = (pm_rest_parameter_node_t) {
+        .base = { .type = PM_REST_PARAMETER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .name = name,
+        .name_loc = name_loc,
+        .operator_loc = operator_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new RetryNode node.
+ */
+pm_retry_node_t *
+pm_retry_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_retry_node_t *node = (pm_retry_node_t *) pm_arena_alloc(arena, sizeof(pm_retry_node_t), PRISM_ALIGNOF(pm_retry_node_t));
+
+    *node = (pm_retry_node_t) {
+        .base = { .type = PM_RETRY_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ReturnNode node.
+ */
+pm_return_node_t *
+pm_return_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t keyword_loc, struct pm_arguments_node *arguments) {
+    pm_return_node_t *node = (pm_return_node_t *) pm_arena_alloc(arena, sizeof(pm_return_node_t), PRISM_ALIGNOF(pm_return_node_t));
+
+    *node = (pm_return_node_t) {
+        .base = { .type = PM_RETURN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .keyword_loc = keyword_loc,
+        .arguments = arguments
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new SelfNode node.
+ */
+pm_self_node_t *
+pm_self_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_self_node_t *node = (pm_self_node_t *) pm_arena_alloc(arena, sizeof(pm_self_node_t), PRISM_ALIGNOF(pm_self_node_t));
+
+    *node = (pm_self_node_t) {
+        .base = { .type = PM_SELF_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new ShareableConstantNode node.
+ */
+pm_shareable_constant_node_t *
+pm_shareable_constant_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, struct pm_node *write) {
+    pm_shareable_constant_node_t *node = (pm_shareable_constant_node_t *) pm_arena_alloc(arena, sizeof(pm_shareable_constant_node_t), PRISM_ALIGNOF(pm_shareable_constant_node_t));
+
+    *node = (pm_shareable_constant_node_t) {
+        .base = { .type = PM_SHAREABLE_CONSTANT_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .write = write
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new SingletonClassNode node.
+ */
+pm_singleton_class_node_t *
+pm_singleton_class_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_constant_id_list_t locals, pm_location_t class_keyword_loc, pm_location_t operator_loc, struct pm_node *expression, struct pm_node *body, pm_location_t end_keyword_loc) {
+    pm_singleton_class_node_t *node = (pm_singleton_class_node_t *) pm_arena_alloc(arena, sizeof(pm_singleton_class_node_t), PRISM_ALIGNOF(pm_singleton_class_node_t));
+
+    *node = (pm_singleton_class_node_t) {
+        .base = { .type = PM_SINGLETON_CLASS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .locals = locals,
+        .class_keyword_loc = class_keyword_loc,
+        .operator_loc = operator_loc,
+        .expression = expression,
+        .body = body,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new SourceEncodingNode node.
+ */
+pm_source_encoding_node_t *
+pm_source_encoding_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_source_encoding_node_t *node = (pm_source_encoding_node_t *) pm_arena_alloc(arena, sizeof(pm_source_encoding_node_t), PRISM_ALIGNOF(pm_source_encoding_node_t));
+
+    *node = (pm_source_encoding_node_t) {
+        .base = { .type = PM_SOURCE_ENCODING_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new SourceFileNode node.
+ */
+pm_source_file_node_t *
+pm_source_file_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_string_t filepath) {
+    pm_source_file_node_t *node = (pm_source_file_node_t *) pm_arena_alloc(arena, sizeof(pm_source_file_node_t), PRISM_ALIGNOF(pm_source_file_node_t));
+
+    *node = (pm_source_file_node_t) {
+        .base = { .type = PM_SOURCE_FILE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .filepath = filepath
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new SourceLineNode node.
+ */
+pm_source_line_node_t *
+pm_source_line_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_source_line_node_t *node = (pm_source_line_node_t *) pm_arena_alloc(arena, sizeof(pm_source_line_node_t), PRISM_ALIGNOF(pm_source_line_node_t));
+
+    *node = (pm_source_line_node_t) {
+        .base = { .type = PM_SOURCE_LINE_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new SplatNode node.
+ */
+pm_splat_node_t *
+pm_splat_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t operator_loc, struct pm_node *expression) {
+    pm_splat_node_t *node = (pm_splat_node_t *) pm_arena_alloc(arena, sizeof(pm_splat_node_t), PRISM_ALIGNOF(pm_splat_node_t));
+
+    *node = (pm_splat_node_t) {
+        .base = { .type = PM_SPLAT_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .operator_loc = operator_loc,
+        .expression = expression
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new StatementsNode node.
+ */
+pm_statements_node_t *
+pm_statements_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_node_list_t body) {
+    pm_statements_node_t *node = (pm_statements_node_t *) pm_arena_alloc(arena, sizeof(pm_statements_node_t), PRISM_ALIGNOF(pm_statements_node_t));
+
+    *node = (pm_statements_node_t) {
+        .base = { .type = PM_STATEMENTS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .body = body
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new StringNode node.
+ */
+pm_string_node_t *
+pm_string_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_location_t content_loc, pm_location_t closing_loc, pm_string_t unescaped) {
+    pm_string_node_t *node = (pm_string_node_t *) pm_arena_alloc(arena, sizeof(pm_string_node_t), PRISM_ALIGNOF(pm_string_node_t));
+
+    *node = (pm_string_node_t) {
+        .base = { .type = PM_STRING_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .content_loc = content_loc,
+        .closing_loc = closing_loc,
+        .unescaped = unescaped
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new SuperNode node.
+ */
+pm_super_node_t *
+pm_super_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t keyword_loc, pm_location_t lparen_loc, struct pm_arguments_node *arguments, pm_location_t rparen_loc, struct pm_node *block) {
+    pm_super_node_t *node = (pm_super_node_t *) pm_arena_alloc(arena, sizeof(pm_super_node_t), PRISM_ALIGNOF(pm_super_node_t));
+
+    *node = (pm_super_node_t) {
+        .base = { .type = PM_SUPER_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .keyword_loc = keyword_loc,
+        .lparen_loc = lparen_loc,
+        .arguments = arguments,
+        .rparen_loc = rparen_loc,
+        .block = block
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new SymbolNode node.
+ */
+pm_symbol_node_t *
+pm_symbol_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_location_t content_loc, pm_location_t closing_loc, pm_string_t unescaped) {
+    pm_symbol_node_t *node = (pm_symbol_node_t *) pm_arena_alloc(arena, sizeof(pm_symbol_node_t), PRISM_ALIGNOF(pm_symbol_node_t));
+
+    *node = (pm_symbol_node_t) {
+        .base = { .type = PM_SYMBOL_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .content_loc = content_loc,
+        .closing_loc = closing_loc,
+        .unescaped = unescaped
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new TrueNode node.
+ */
+pm_true_node_t *
+pm_true_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location) {
+    pm_true_node_t *node = (pm_true_node_t *) pm_arena_alloc(arena, sizeof(pm_true_node_t), PRISM_ALIGNOF(pm_true_node_t));
+
+    *node = (pm_true_node_t) {
+        .base = { .type = PM_TRUE_NODE, .flags = flags, .node_id = node_id, .location = location }
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new UndefNode node.
+ */
+pm_undef_node_t *
+pm_undef_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_node_list_t names, pm_location_t keyword_loc) {
+    pm_undef_node_t *node = (pm_undef_node_t *) pm_arena_alloc(arena, sizeof(pm_undef_node_t), PRISM_ALIGNOF(pm_undef_node_t));
+
+    *node = (pm_undef_node_t) {
+        .base = { .type = PM_UNDEF_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .names = names,
+        .keyword_loc = keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new UnlessNode node.
+ */
+pm_unless_node_t *
+pm_unless_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t unless_keyword_loc, struct pm_node *predicate, pm_location_t then_keyword_loc, struct pm_statements_node *statements, struct pm_else_node *else_clause, pm_location_t end_keyword_loc) {
+    pm_unless_node_t *node = (pm_unless_node_t *) pm_arena_alloc(arena, sizeof(pm_unless_node_t), PRISM_ALIGNOF(pm_unless_node_t));
+
+    *node = (pm_unless_node_t) {
+        .base = { .type = PM_UNLESS_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .unless_keyword_loc = unless_keyword_loc,
+        .predicate = predicate,
+        .then_keyword_loc = then_keyword_loc,
+        .statements = statements,
+        .else_clause = else_clause,
+        .end_keyword_loc = end_keyword_loc
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new UntilNode node.
+ */
+pm_until_node_t *
+pm_until_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t until_keyword_loc, pm_location_t do_keyword_loc, pm_location_t end_keyword_loc, struct pm_node *predicate, struct pm_statements_node *statements) {
+    pm_until_node_t *node = (pm_until_node_t *) pm_arena_alloc(arena, sizeof(pm_until_node_t), PRISM_ALIGNOF(pm_until_node_t));
+
+    *node = (pm_until_node_t) {
+        .base = { .type = PM_UNTIL_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .until_keyword_loc = until_keyword_loc,
+        .do_keyword_loc = do_keyword_loc,
+        .end_keyword_loc = end_keyword_loc,
+        .predicate = predicate,
+        .statements = statements
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new WhenNode node.
+ */
+pm_when_node_t *
+pm_when_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t when_keyword_loc, pm_node_list_t conditions, pm_location_t then_keyword_loc, struct pm_statements_node *statements) {
+    pm_when_node_t *node = (pm_when_node_t *) pm_arena_alloc(arena, sizeof(pm_when_node_t), PRISM_ALIGNOF(pm_when_node_t));
+
+    *node = (pm_when_node_t) {
+        .base = { .type = PM_WHEN_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .when_keyword_loc = when_keyword_loc,
+        .conditions = conditions,
+        .then_keyword_loc = then_keyword_loc,
+        .statements = statements
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new WhileNode node.
+ */
+pm_while_node_t *
+pm_while_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t while_keyword_loc, pm_location_t do_keyword_loc, pm_location_t end_keyword_loc, struct pm_node *predicate, struct pm_statements_node *statements) {
+    pm_while_node_t *node = (pm_while_node_t *) pm_arena_alloc(arena, sizeof(pm_while_node_t), PRISM_ALIGNOF(pm_while_node_t));
+
+    *node = (pm_while_node_t) {
+        .base = { .type = PM_WHILE_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .while_keyword_loc = while_keyword_loc,
+        .do_keyword_loc = do_keyword_loc,
+        .end_keyword_loc = end_keyword_loc,
+        .predicate = predicate,
+        .statements = statements
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new XStringNode node.
+ */
+pm_x_string_node_t *
+pm_x_string_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t opening_loc, pm_location_t content_loc, pm_location_t closing_loc, pm_string_t unescaped) {
+    pm_x_string_node_t *node = (pm_x_string_node_t *) pm_arena_alloc(arena, sizeof(pm_x_string_node_t), PRISM_ALIGNOF(pm_x_string_node_t));
+
+    *node = (pm_x_string_node_t) {
+        .base = { .type = PM_X_STRING_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .opening_loc = opening_loc,
+        .content_loc = content_loc,
+        .closing_loc = closing_loc,
+        .unescaped = unescaped
+    };
+
+    return node;
+}
+
+/**
+ * Allocate and initialize a new YieldNode node.
+ */
+pm_yield_node_t *
+pm_yield_node_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location, pm_location_t keyword_loc, pm_location_t lparen_loc, struct pm_arguments_node *arguments, pm_location_t rparen_loc) {
+    pm_yield_node_t *node = (pm_yield_node_t *) pm_arena_alloc(arena, sizeof(pm_yield_node_t), PRISM_ALIGNOF(pm_yield_node_t));
+
+    *node = (pm_yield_node_t) {
+        .base = { .type = PM_YIELD_NODE, .flags = flags, .node_id = node_id, .location = location },
+        .keyword_loc = keyword_loc,
+        .lparen_loc = lparen_loc,
+        .arguments = arguments,
+        .rparen_loc = rparen_loc
+    };
+
+    return node;
+}