serialize.c

/*----------------------------------------------------------------------------*/
/* This file is generated by the templates/template.rb script and should not  */
/* be modified manually. See                                                  */
/* templates/src/serialize.c.erb                                              */
/* if you are looking to modify the                                           */
/* template                                                                   */
/*----------------------------------------------------------------------------*/
 
#include "prism/excludes.h"
 
/* We optionally support serializing to a binary string. For systems that do not
 * want or need this functionality, it can be turned off with the
 * PRISM_EXCLUDE_SERIALIZATION define. */
#ifdef PRISM_EXCLUDE_SERIALIZATION
 
/* Ensure this translation unit is never empty, even when serialization is
 * excluded. */
typedef int pm_serialize_unused_t;
 
#else
 
#include "prism/compiler/branch.h"
#include "prism/compiler/inline.h"
 
#include "prism/internal/allocator.h"
#include "prism/internal/buffer.h"
#include "prism/internal/comments.h"
#include "prism/internal/diagnostic.h"
#include "prism/internal/encoding.h"
#include "prism/internal/list.h"
#include "prism/internal/magic_comments.h"
#include "prism/internal/options.h"
#include "prism/internal/parser.h"
 
#include "prism.h"
#include "prism/ast.h"
#include "prism/line_offset_list.h"
 
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static PRISM_INLINE uint32_t
pm_ptrdifft_to_u32(ptrdiff_t value) {
    assert(value >= 0 && ((unsigned long) value) < UINT32_MAX);
    return (uint32_t) value;
}
 
static PRISM_INLINE uint32_t
pm_sizet_to_u32(size_t value) {
    assert(value < UINT32_MAX);
    return (uint32_t) value;
}
 
static void
pm_serialize_location(const pm_location_t *location, pm_buffer_t *buffer) {
    pm_buffer_append_varuint(buffer, location->start);
    pm_buffer_append_varuint(buffer, location->length);
}
 
static void
pm_serialize_string(const pm_string_t *string, pm_buffer_t *buffer) {
    uint32_t length = pm_sizet_to_u32(pm_string_length(string));
    pm_buffer_append_varuint(buffer, length);
    pm_buffer_append_bytes(buffer, pm_string_source(string), length);
}
 
static void
pm_serialize_integer(const pm_integer_t *integer, pm_buffer_t *buffer) {
    pm_buffer_append_byte(buffer, integer->negative ? 1 : 0);
    if (integer->values == NULL) {
        pm_buffer_append_varuint(buffer, pm_sizet_to_u32(1));
        pm_buffer_append_varuint(buffer, integer->value);
    } else {
        pm_buffer_append_varuint(buffer, pm_sizet_to_u32(integer->length));
        for (size_t i = 0; i < integer->length; i++) {
            pm_buffer_append_varuint(buffer, integer->values[i]);
        }
    }
}
 
typedef enum {
    PM_SERIALIZE_ENTRY_NODE,
 
    PM_SERIALIZE_ENTRY_LAZY_HEADER,
 
    PM_SERIALIZE_ENTRY_LAZY_START,
 
    PM_SERIALIZE_ENTRY_LAZY_END
} pm_serialize_entry_kind_t;
 
typedef struct {
    const pm_node_t *node;
 
    size_t offset;
 
    pm_serialize_entry_kind_t kind;
 
    bool visited;
} pm_serialize_entry_t;
 
typedef struct {
    pm_serialize_entry_t *entries;
 
    size_t size;
 
    size_t capacity;
} pm_serialize_stack_t;
 
static void
pm_serialize_stack_push(pm_serialize_stack_t *stack, pm_serialize_entry_kind_t kind, const pm_node_t *node, size_t offset) {
    if (PRISM_UNLIKELY(stack->size == stack->capacity)) {
        size_t capacity = stack->capacity == 0 ? 64 : stack->capacity * 2;
        pm_serialize_entry_t *entries = (pm_serialize_entry_t *) xrealloc_sized(stack->entries, capacity * sizeof(pm_serialize_entry_t), stack->capacity * sizeof(pm_serialize_entry_t));
 
        if (PRISM_UNLIKELY(entries == NULL)) {
            fprintf(stderr, "prism: out of memory; aborting\n");
            abort();
        }
 
        stack->entries = entries;
        stack->capacity = capacity;
    }
 
    stack->entries[stack->size++] = (pm_serialize_entry_t) { .node = node, .offset = offset, .kind = kind, .visited = false };
}
 
static void
pm_serialize_node(pm_node_t *root, pm_buffer_t *buffer) {
    pm_serialize_stack_t stack = { 0 };
    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, root, 0);
 
    while (stack.size > 0) {
        pm_serialize_entry_t *entry = &stack.entries[--stack.size];
 
        switch (entry->kind) {
            case PM_SERIALIZE_ENTRY_LAZY_HEADER: {
                pm_buffer_append_byte(buffer, 255);
                stack.entries[entry->offset].offset = buffer->length;
                pm_buffer_append_zeroes(buffer, 8);
                continue;
            }
            case PM_SERIALIZE_ENTRY_LAZY_START: {
                size_t offset = stack.entries[entry->offset].offset;
                uint32_t skip = pm_sizet_to_u32(buffer->length - offset - 8);
                memcpy(buffer->value + offset, &skip, sizeof(uint32_t));
                continue;
            }
            case PM_SERIALIZE_ENTRY_LAZY_END: {
                size_t offset = stack.entries[entry->offset].offset;
                uint32_t skip;
                memcpy(&skip, buffer->value + offset, sizeof(uint32_t));
 
                uint32_t length = pm_sizet_to_u32(buffer->length - offset - 8 - skip);
                memcpy(buffer->value + offset + 4, &length, sizeof(uint32_t));
                continue;
            }
            case PM_SERIALIZE_ENTRY_NODE:
                break;
        }
 
        const pm_node_t *node = entry->node;
 
        if (node == NULL) {
            pm_buffer_append_byte(buffer, 0);
            continue;
        }
 
        if (!entry->visited) {
            /* Leave the node on the stack beneath its children, which are
             * pushed in reverse field order so that they are popped, and
             * therefore written, in field order. A node without children is
             * written straight away instead. */
            entry->visited = true;
            size_t index = stack.size++;
 
            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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->old_name, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->new_name, 0);
                    break;
                }
                case PM_ALIAS_METHOD_NODE: {
                    const pm_alias_method_node_t *cast = (const pm_alias_method_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->old_name, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->new_name, 0);
                    break;
                }
                case PM_ALTERNATION_PATTERN_NODE: {
                    const pm_alternation_pattern_node_t *cast = (const pm_alternation_pattern_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
                    break;
                }
                case PM_AND_NODE: {
                    const pm_and_node_t *cast = (const pm_and_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
                    break;
                }
                case PM_ARGUMENTS_NODE: {
                    const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
                    for (size_t list_index = cast->arguments.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->arguments.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_ARRAY_NODE: {
                    const pm_array_node_t *cast = (const pm_array_node_t *) node;
                    for (size_t list_index = cast->elements.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->elements.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_ARRAY_PATTERN_NODE: {
                    const pm_array_pattern_node_t *cast = (const pm_array_pattern_node_t *) node;
                    for (size_t list_index = cast->posts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->posts.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
                    for (size_t list_index = cast->requireds.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->requireds.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant, 0);
                    break;
                }
                case PM_ASSOC_NODE: {
                    const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->key, 0);
                    break;
                }
                case PM_ASSOC_SPLAT_NODE: {
                    const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_BEGIN_NODE: {
                    const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->ensure_clause, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->else_clause, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rescue_clause, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    break;
                }
                case PM_BLOCK_ARGUMENT_NODE: {
                    const pm_block_argument_node_t *cast = (const pm_block_argument_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
                    break;
                }
                case PM_BLOCK_NODE: {
                    const pm_block_node_t *cast = (const pm_block_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parameters, 0);
                    break;
                }
                case PM_BLOCK_PARAMETERS_NODE: {
                    const pm_block_parameters_node_t *cast = (const pm_block_parameters_node_t *) node;
                    for (size_t list_index = cast->locals.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->locals.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parameters, 0);
                    break;
                }
                case PM_BREAK_NODE: {
                    const pm_break_node_t *cast = (const pm_break_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    break;
                }
                case PM_CALL_AND_WRITE_NODE: {
                    const pm_call_and_write_node_t *cast = (const pm_call_and_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    break;
                }
                case PM_CALL_NODE: {
                    const pm_call_node_t *cast = (const pm_call_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    break;
                }
                case PM_CALL_OPERATOR_WRITE_NODE: {
                    const pm_call_operator_write_node_t *cast = (const pm_call_operator_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    break;
                }
                case PM_CALL_OR_WRITE_NODE: {
                    const pm_call_or_write_node_t *cast = (const pm_call_or_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    break;
                }
                case PM_CALL_TARGET_NODE: {
                    const pm_call_target_node_t *cast = (const pm_call_target_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    break;
                }
                case PM_CAPTURE_PATTERN_NODE: {
                    const pm_capture_pattern_node_t *cast = (const pm_capture_pattern_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_CASE_MATCH_NODE: {
                    const pm_case_match_node_t *cast = (const pm_case_match_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->else_clause, 0);
                    for (size_t list_index = cast->conditions.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->conditions.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
                    break;
                }
                case PM_CASE_NODE: {
                    const pm_case_node_t *cast = (const pm_case_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->else_clause, 0);
                    for (size_t list_index = cast->conditions.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->conditions.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
                    break;
                }
                case PM_CLASS_NODE: {
                    const pm_class_node_t *cast = (const pm_class_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->superclass, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant_path, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_CLASS_VARIABLE_WRITE_NODE: {
                    const pm_class_variable_write_node_t *cast = (const pm_class_variable_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_CONSTANT_AND_WRITE_NODE: {
                    const pm_constant_and_write_node_t *cast = (const pm_constant_and_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_CONSTANT_OPERATOR_WRITE_NODE: {
                    const pm_constant_operator_write_node_t *cast = (const pm_constant_operator_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_CONSTANT_OR_WRITE_NODE: {
                    const pm_constant_or_write_node_t *cast = (const pm_constant_or_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
                    break;
                }
                case PM_CONSTANT_PATH_NODE: {
                    const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parent, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
                    break;
                }
                case PM_CONSTANT_PATH_TARGET_NODE: {
                    const pm_constant_path_target_node_t *cast = (const pm_constant_path_target_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parent, 0);
                    break;
                }
                case PM_CONSTANT_PATH_WRITE_NODE: {
                    const pm_constant_path_write_node_t *cast = (const pm_constant_path_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
                    break;
                }
                case PM_CONSTANT_WRITE_NODE: {
                    const pm_constant_write_node_t *cast = (const pm_constant_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_DEF_NODE: {
                    const pm_def_node_t *cast = (const pm_def_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_LAZY_END, NULL, index);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_LAZY_START, NULL, index);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parameters, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_LAZY_HEADER, NULL, index);
                    break;
                }
                case PM_DEFINED_NODE: {
                    const pm_defined_node_t *cast = (const pm_defined_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_ELSE_NODE: {
                    const pm_else_node_t *cast = (const pm_else_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    break;
                }
                case PM_EMBEDDED_STATEMENTS_NODE: {
                    const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    break;
                }
                case PM_EMBEDDED_VARIABLE_NODE: {
                    const pm_embedded_variable_node_t *cast = (const pm_embedded_variable_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->variable, 0);
                    break;
                }
                case PM_ENSURE_NODE: {
                    const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    break;
                }
                case PM_ERROR_RECOVERY_NODE: {
                    const pm_error_recovery_node_t *cast = (const pm_error_recovery_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->unexpected, 0);
                    break;
                }
                case PM_FIND_PATTERN_NODE: {
                    const pm_find_pattern_node_t *cast = (const pm_find_pattern_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
                    for (size_t list_index = cast->requireds.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->requireds.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant, 0);
                    break;
                }
                case PM_FLIP_FLOP_NODE: {
                    const pm_flip_flop_node_t *cast = (const pm_flip_flop_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
                    break;
                }
                case PM_FOR_NODE: {
                    const pm_for_node_t *cast = (const pm_for_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->collection, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->index, 0);
                    break;
                }
                case PM_FORWARDING_SUPER_NODE: {
                    const pm_forwarding_super_node_t *cast = (const pm_forwarding_super_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_GLOBAL_VARIABLE_WRITE_NODE: {
                    const pm_global_variable_write_node_t *cast = (const pm_global_variable_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_HASH_NODE: {
                    const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
                    for (size_t list_index = cast->elements.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->elements.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_HASH_PATTERN_NODE: {
                    const pm_hash_pattern_node_t *cast = (const pm_hash_pattern_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
                    for (size_t list_index = cast->elements.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->elements.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant, 0);
                    break;
                }
                case PM_IF_NODE: {
                    const pm_if_node_t *cast = (const pm_if_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->subsequent, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
                    break;
                }
                case PM_IMAGINARY_NODE: {
                    const pm_imaginary_node_t *cast = (const pm_imaginary_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->numeric, 0);
                    break;
                }
                case PM_IMPLICIT_NODE: {
                    const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_IN_NODE: {
                    const pm_in_node_t *cast = (const pm_in_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->pattern, 0);
                    break;
                }
                case PM_INDEX_AND_WRITE_NODE: {
                    const pm_index_and_write_node_t *cast = (const pm_index_and_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    break;
                }
                case PM_INDEX_OPERATOR_WRITE_NODE: {
                    const pm_index_operator_write_node_t *cast = (const pm_index_operator_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    break;
                }
                case PM_INDEX_OR_WRITE_NODE: {
                    const pm_index_or_write_node_t *cast = (const pm_index_or_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    break;
                }
                case PM_INDEX_TARGET_NODE: {
                    const pm_index_target_node_t *cast = (const pm_index_target_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_INSTANCE_VARIABLE_WRITE_NODE: {
                    const pm_instance_variable_write_node_t *cast = (const pm_instance_variable_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
                    const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) node;
                    for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_INTERPOLATED_STRING_NODE: {
                    const pm_interpolated_string_node_t *cast = (const pm_interpolated_string_node_t *) node;
                    for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_INTERPOLATED_SYMBOL_NODE: {
                    const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
                    for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_INTERPOLATED_X_STRING_NODE: {
                    const pm_interpolated_x_string_node_t *cast = (const pm_interpolated_x_string_node_t *) node;
                    for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_KEYWORD_HASH_NODE: {
                    const pm_keyword_hash_node_t *cast = (const pm_keyword_hash_node_t *) node;
                    for (size_t list_index = cast->elements.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->elements.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_LAMBDA_NODE: {
                    const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parameters, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    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;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_LOCAL_VARIABLE_WRITE_NODE: {
                    const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_MATCH_PREDICATE_NODE: {
                    const pm_match_predicate_node_t *cast = (const pm_match_predicate_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->pattern, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_MATCH_REQUIRED_NODE: {
                    const pm_match_required_node_t *cast = (const pm_match_required_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->pattern, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_MATCH_WRITE_NODE: {
                    const pm_match_write_node_t *cast = (const pm_match_write_node_t *) node;
                    for (size_t list_index = cast->targets.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->targets.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->call, 0);
                    break;
                }
                case PM_MODULE_NODE: {
                    const pm_module_node_t *cast = (const pm_module_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant_path, 0);
                    break;
                }
                case PM_MULTI_TARGET_NODE: {
                    const pm_multi_target_node_t *cast = (const pm_multi_target_node_t *) node;
                    for (size_t list_index = cast->rights.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->rights.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
                    for (size_t list_index = cast->lefts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->lefts.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_MULTI_WRITE_NODE: {
                    const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    for (size_t list_index = cast->rights.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->rights.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
                    for (size_t list_index = cast->lefts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->lefts.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_NEXT_NODE: {
                    const pm_next_node_t *cast = (const pm_next_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    break;
                }
                case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
                    const pm_optional_keyword_parameter_node_t *cast = (const pm_optional_keyword_parameter_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_OPTIONAL_PARAMETER_NODE: {
                    const pm_optional_parameter_node_t *cast = (const pm_optional_parameter_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
                    break;
                }
                case PM_OR_NODE: {
                    const pm_or_node_t *cast = (const pm_or_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
                    break;
                }
                case PM_PARAMETERS_NODE: {
                    const pm_parameters_node_t *cast = (const pm_parameters_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->keyword_rest, 0);
                    for (size_t list_index = cast->keywords.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->keywords.nodes[list_index - 1], 0);
                    }
                    for (size_t list_index = cast->posts.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->posts.nodes[list_index - 1], 0);
                    }
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
                    for (size_t list_index = cast->optionals.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->optionals.nodes[list_index - 1], 0);
                    }
                    for (size_t list_index = cast->requireds.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->requireds.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_PARENTHESES_NODE: {
                    const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
                    break;
                }
                case PM_PINNED_EXPRESSION_NODE: {
                    const pm_pinned_expression_node_t *cast = (const pm_pinned_expression_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
                    break;
                }
                case PM_PINNED_VARIABLE_NODE: {
                    const pm_pinned_variable_node_t *cast = (const pm_pinned_variable_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->variable, 0);
                    break;
                }
                case PM_POST_EXECUTION_NODE: {
                    const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    break;
                }
                case PM_PRE_EXECUTION_NODE: {
                    const pm_pre_execution_node_t *cast = (const pm_pre_execution_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    break;
                }
                case PM_PROGRAM_NODE: {
                    const pm_program_node_t *cast = (const pm_program_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    break;
                }
                case PM_RANGE_NODE: {
                    const pm_range_node_t *cast = (const pm_range_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
                    break;
                }
                case PM_RESCUE_MODIFIER_NODE: {
                    const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rescue_expression, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
                    break;
                }
                case PM_RESCUE_NODE: {
                    const pm_rescue_node_t *cast = (const pm_rescue_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->subsequent, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->reference, 0);
                    for (size_t list_index = cast->exceptions.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->exceptions.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_RETURN_NODE: {
                    const pm_return_node_t *cast = (const pm_return_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    break;
                }
                case PM_SHAREABLE_CONSTANT_NODE: {
                    const pm_shareable_constant_node_t *cast = (const pm_shareable_constant_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->write, 0);
                    break;
                }
                case PM_SINGLETON_CLASS_NODE: {
                    const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
                    break;
                }
                case PM_SPLAT_NODE: {
                    const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
                    break;
                }
                case PM_STATEMENTS_NODE: {
                    const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
                    for (size_t list_index = cast->body.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->body.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_SUPER_NODE: {
                    const pm_super_node_t *cast = (const pm_super_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    break;
                }
                case PM_UNDEF_NODE: {
                    const pm_undef_node_t *cast = (const pm_undef_node_t *) node;
                    for (size_t list_index = cast->names.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->names.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_UNLESS_NODE: {
                    const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->else_clause, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
                    break;
                }
                case PM_UNTIL_NODE: {
                    const pm_until_node_t *cast = (const pm_until_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
                    break;
                }
                case PM_WHEN_NODE: {
                    const pm_when_node_t *cast = (const pm_when_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    for (size_t list_index = cast->conditions.size; list_index > 0; list_index--) {
                        pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->conditions.nodes[list_index - 1], 0);
                    }
                    break;
                }
                case PM_WHILE_NODE: {
                    const pm_while_node_t *cast = (const pm_while_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
                    break;
                }
                case PM_YIELD_NODE: {
                    const pm_yield_node_t *cast = (const pm_yield_node_t *) node;
                    pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
                    break;
                }
                default:
                    break;
            }
 
            if (stack.size != index + 1) continue;
            stack.size--;
        }
 
        pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node));
        pm_buffer_append_varuint(buffer, node->node_id);
        pm_serialize_location(&node->location, buffer);
 
        switch (PM_NODE_TYPE(node)) {
            /* A ScopeNode is never part of the tree, so it has no fields to
             * serialize. */
            case PM_SCOPE_NODE:
                break;
            case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
                const pm_alias_global_variable_node_t *cast = (const pm_alias_global_variable_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_ALIAS_METHOD_NODE: {
                const pm_alias_method_node_t *cast = (const pm_alias_method_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_ALTERNATION_PATTERN_NODE: {
                const pm_alternation_pattern_node_t *cast = (const pm_alternation_pattern_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_AND_NODE: {
                const pm_and_node_t *cast = (const pm_and_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_ARGUMENTS_NODE: {
                const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->arguments.size));
                break;
            }
            case PM_ARRAY_NODE: {
                const pm_array_node_t *cast = (const pm_array_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->elements.size));
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                break;
            }
            case PM_ARRAY_PATTERN_NODE: {
                const pm_array_pattern_node_t *cast = (const pm_array_pattern_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->requireds.size));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->posts.size));
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                break;
            }
            case PM_ASSOC_NODE: {
                const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->operator_loc, buffer);
                }
                break;
            }
            case PM_ASSOC_SPLAT_NODE: {
                const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_BACK_REFERENCE_READ_NODE: {
                const pm_back_reference_read_node_t *cast = (const pm_back_reference_read_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_BEGIN_NODE: {
                const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->begin_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->begin_keyword_loc, buffer);
                }
                if (cast->end_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->end_keyword_loc, buffer);
                }
                break;
            }
            case PM_BLOCK_ARGUMENT_NODE: {
                const pm_block_argument_node_t *cast = (const pm_block_argument_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_BLOCK_LOCAL_VARIABLE_NODE: {
                const pm_block_local_variable_node_t *cast = (const pm_block_local_variable_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_BLOCK_NODE: {
                const pm_block_node_t *cast = (const pm_block_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
                for (size_t index = 0; index < cast->locals.size; index++) {
                    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
                }
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_BLOCK_PARAMETER_NODE: {
                const pm_block_parameter_node_t *cast = (const pm_block_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                if (cast->name_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->name_loc, buffer);
                }
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_BLOCK_PARAMETERS_NODE: {
                const pm_block_parameters_node_t *cast = (const pm_block_parameters_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                break;
            }
            case PM_BREAK_NODE: {
                const pm_break_node_t *cast = (const pm_break_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_CALL_AND_WRITE_NODE: {
                const pm_call_and_write_node_t *cast = (const pm_call_and_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->call_operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->call_operator_loc, buffer);
                }
                if (cast->message_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->message_loc, buffer);
                }
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->read_name));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->write_name));
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CALL_NODE: {
                const pm_call_node_t *cast = (const pm_call_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->call_operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->call_operator_loc, buffer);
                }
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                if (cast->message_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->message_loc, buffer);
                }
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                if (cast->equal_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->equal_loc, buffer);
                }
                break;
            }
            case PM_CALL_OPERATOR_WRITE_NODE: {
                const pm_call_operator_write_node_t *cast = (const pm_call_operator_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->call_operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->call_operator_loc, buffer);
                }
                if (cast->message_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->message_loc, buffer);
                }
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->read_name));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->write_name));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
                pm_serialize_location(&cast->binary_operator_loc, buffer);
                break;
            }
            case PM_CALL_OR_WRITE_NODE: {
                const pm_call_or_write_node_t *cast = (const pm_call_or_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->call_operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->call_operator_loc, buffer);
                }
                if (cast->message_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->message_loc, buffer);
                }
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->read_name));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->write_name));
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CALL_TARGET_NODE: {
                const pm_call_target_node_t *cast = (const pm_call_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->call_operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->message_loc, buffer);
                break;
            }
            case PM_CAPTURE_PATTERN_NODE: {
                const pm_capture_pattern_node_t *cast = (const pm_capture_pattern_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CASE_MATCH_NODE: {
                const pm_case_match_node_t *cast = (const pm_case_match_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->conditions.size));
                pm_serialize_location(&cast->case_keyword_loc, buffer);
                pm_serialize_location(&cast->end_keyword_loc, buffer);
                break;
            }
            case PM_CASE_NODE: {
                const pm_case_node_t *cast = (const pm_case_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->conditions.size));
                pm_serialize_location(&cast->case_keyword_loc, buffer);
                pm_serialize_location(&cast->end_keyword_loc, buffer);
                break;
            }
            case PM_CLASS_NODE: {
                const pm_class_node_t *cast = (const pm_class_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
                for (size_t index = 0; index < cast->locals.size; index++) {
                    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
                }
                pm_serialize_location(&cast->class_keyword_loc, buffer);
                if (cast->inheritance_operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->inheritance_operator_loc, buffer);
                }
                pm_serialize_location(&cast->end_keyword_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->binary_operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CLASS_VARIABLE_READ_NODE: {
                const pm_class_variable_read_node_t *cast = (const pm_class_variable_read_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_CLASS_VARIABLE_TARGET_NODE: {
                const pm_class_variable_target_node_t *cast = (const pm_class_variable_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_CLASS_VARIABLE_WRITE_NODE: {
                const pm_class_variable_write_node_t *cast = (const pm_class_variable_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CONSTANT_AND_WRITE_NODE: {
                const pm_constant_and_write_node_t *cast = (const pm_constant_and_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CONSTANT_OPERATOR_WRITE_NODE: {
                const pm_constant_operator_write_node_t *cast = (const pm_constant_operator_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->binary_operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
                break;
            }
            case PM_CONSTANT_OR_WRITE_NODE: {
                const pm_constant_or_write_node_t *cast = (const pm_constant_or_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CONSTANT_PATH_NODE: {
                const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->delimiter_loc, buffer);
                pm_serialize_location(&cast->name_loc, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->binary_operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CONSTANT_PATH_TARGET_NODE: {
                const pm_constant_path_target_node_t *cast = (const pm_constant_path_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->delimiter_loc, buffer);
                pm_serialize_location(&cast->name_loc, buffer);
                break;
            }
            case PM_CONSTANT_PATH_WRITE_NODE: {
                const pm_constant_path_write_node_t *cast = (const pm_constant_path_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_CONSTANT_READ_NODE: {
                const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_CONSTANT_TARGET_NODE: {
                const pm_constant_target_node_t *cast = (const pm_constant_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_CONSTANT_WRITE_NODE: {
                const pm_constant_write_node_t *cast = (const pm_constant_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_DEF_NODE: {
                const pm_def_node_t *cast = (const pm_def_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
                for (size_t index = 0; index < cast->locals.size; index++) {
                    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
                }
                pm_serialize_location(&cast->def_keyword_loc, buffer);
                if (cast->operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->operator_loc, buffer);
                }
                if (cast->lparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->lparen_loc, buffer);
                }
                if (cast->rparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->rparen_loc, buffer);
                }
                if (cast->equal_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->equal_loc, buffer);
                }
                if (cast->end_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->end_keyword_loc, buffer);
                }
                break;
            }
            case PM_DEFINED_NODE: {
                const pm_defined_node_t *cast = (const pm_defined_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->lparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->lparen_loc, buffer);
                }
                if (cast->rparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->rparen_loc, buffer);
                }
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_ELSE_NODE: {
                const pm_else_node_t *cast = (const pm_else_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->else_keyword_loc, buffer);
                if (cast->end_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->end_keyword_loc, buffer);
                }
                break;
            }
            case PM_EMBEDDED_STATEMENTS_NODE: {
                const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_EMBEDDED_VARIABLE_NODE: {
                const pm_embedded_variable_node_t *cast = (const pm_embedded_variable_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_ENSURE_NODE: {
                const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->ensure_keyword_loc, buffer);
                pm_serialize_location(&cast->end_keyword_loc, buffer);
                break;
            }
            case PM_ERROR_RECOVERY_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_FALSE_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_FIND_PATTERN_NODE: {
                const pm_find_pattern_node_t *cast = (const pm_find_pattern_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->requireds.size));
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                break;
            }
            case PM_FLIP_FLOP_NODE: {
                const pm_flip_flop_node_t *cast = (const pm_flip_flop_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_FLOAT_NODE: {
                const pm_float_node_t *cast = (const pm_float_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_double(buffer, cast->value);
                break;
            }
            case PM_FOR_NODE: {
                const pm_for_node_t *cast = (const pm_for_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->for_keyword_loc, buffer);
                pm_serialize_location(&cast->in_keyword_loc, buffer);
                if (cast->do_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->do_keyword_loc, buffer);
                }
                pm_serialize_location(&cast->end_keyword_loc, buffer);
                break;
            }
            case PM_FORWARDING_ARGUMENTS_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_FORWARDING_PARAMETER_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_FORWARDING_SUPER_NODE: {
                const pm_forwarding_super_node_t *cast = (const pm_forwarding_super_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->binary_operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_GLOBAL_VARIABLE_READ_NODE: {
                const pm_global_variable_read_node_t *cast = (const pm_global_variable_read_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_GLOBAL_VARIABLE_TARGET_NODE: {
                const pm_global_variable_target_node_t *cast = (const pm_global_variable_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_GLOBAL_VARIABLE_WRITE_NODE: {
                const pm_global_variable_write_node_t *cast = (const pm_global_variable_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_HASH_NODE: {
                const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->elements.size));
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_HASH_PATTERN_NODE: {
                const pm_hash_pattern_node_t *cast = (const pm_hash_pattern_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->elements.size));
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                break;
            }
            case PM_IF_NODE: {
                const pm_if_node_t *cast = (const pm_if_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->if_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->if_keyword_loc, buffer);
                }
                if (cast->then_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->then_keyword_loc, buffer);
                }
                if (cast->end_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->end_keyword_loc, buffer);
                }
                break;
            }
            case PM_IMAGINARY_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_IMPLICIT_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_IMPLICIT_REST_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_IN_NODE: {
                const pm_in_node_t *cast = (const pm_in_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->in_keyword_loc, buffer);
                if (cast->then_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->then_keyword_loc, buffer);
                }
                break;
            }
            case PM_INDEX_AND_WRITE_NODE: {
                const pm_index_and_write_node_t *cast = (const pm_index_and_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->call_operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->call_operator_loc, buffer);
                }
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_INDEX_OPERATOR_WRITE_NODE: {
                const pm_index_operator_write_node_t *cast = (const pm_index_operator_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->call_operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->call_operator_loc, buffer);
                }
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
                pm_serialize_location(&cast->binary_operator_loc, buffer);
                break;
            }
            case PM_INDEX_OR_WRITE_NODE: {
                const pm_index_or_write_node_t *cast = (const pm_index_or_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->call_operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->call_operator_loc, buffer);
                }
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_INDEX_TARGET_NODE: {
                const pm_index_target_node_t *cast = (const pm_index_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->binary_operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_INSTANCE_VARIABLE_READ_NODE: {
                const pm_instance_variable_read_node_t *cast = (const pm_instance_variable_read_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_INSTANCE_VARIABLE_TARGET_NODE: {
                const pm_instance_variable_target_node_t *cast = (const pm_instance_variable_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_INSTANCE_VARIABLE_WRITE_NODE: {
                const pm_instance_variable_write_node_t *cast = (const pm_instance_variable_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_INTEGER_NODE: {
                const pm_integer_node_t *cast = (const pm_integer_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_integer(&cast->value, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
                const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_INTERPOLATED_STRING_NODE: {
                const pm_interpolated_string_node_t *cast = (const pm_interpolated_string_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                break;
            }
            case PM_INTERPOLATED_SYMBOL_NODE: {
                const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                break;
            }
            case PM_INTERPOLATED_X_STRING_NODE: {
                const pm_interpolated_x_string_node_t *cast = (const pm_interpolated_x_string_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_IT_LOCAL_VARIABLE_READ_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_IT_PARAMETERS_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_KEYWORD_HASH_NODE: {
                const pm_keyword_hash_node_t *cast = (const pm_keyword_hash_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->elements.size));
                break;
            }
            case PM_KEYWORD_REST_PARAMETER_NODE: {
                const pm_keyword_rest_parameter_node_t *cast = (const pm_keyword_rest_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                if (cast->name_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->name_loc, buffer);
                }
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_LAMBDA_NODE: {
                const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
                for (size_t index = 0; index < cast->locals.size; index++) {
                    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
                }
                pm_serialize_location(&cast->operator_loc, buffer);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_buffer_append_varuint(buffer, cast->depth);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->binary_operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
                pm_buffer_append_varuint(buffer, cast->depth);
                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;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_buffer_append_varuint(buffer, cast->depth);
                break;
            }
            case PM_LOCAL_VARIABLE_READ_NODE: {
                const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_buffer_append_varuint(buffer, cast->depth);
                break;
            }
            case PM_LOCAL_VARIABLE_TARGET_NODE: {
                const pm_local_variable_target_node_t *cast = (const pm_local_variable_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_buffer_append_varuint(buffer, cast->depth);
                break;
            }
            case PM_LOCAL_VARIABLE_WRITE_NODE: {
                const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_buffer_append_varuint(buffer, cast->depth);
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_MATCH_LAST_LINE_NODE: {
                const pm_match_last_line_node_t *cast = (const pm_match_last_line_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->content_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                pm_serialize_string(&cast->unescaped, buffer);
                break;
            }
            case PM_MATCH_PREDICATE_NODE: {
                const pm_match_predicate_node_t *cast = (const pm_match_predicate_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_MATCH_REQUIRED_NODE: {
                const pm_match_required_node_t *cast = (const pm_match_required_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_MATCH_WRITE_NODE: {
                const pm_match_write_node_t *cast = (const pm_match_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->targets.size));
                break;
            }
            case PM_MODULE_NODE: {
                const pm_module_node_t *cast = (const pm_module_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
                for (size_t index = 0; index < cast->locals.size; index++) {
                    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
                }
                pm_serialize_location(&cast->module_keyword_loc, buffer);
                pm_serialize_location(&cast->end_keyword_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_MULTI_TARGET_NODE: {
                const pm_multi_target_node_t *cast = (const pm_multi_target_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->lefts.size));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->rights.size));
                if (cast->lparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->lparen_loc, buffer);
                }
                if (cast->rparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->rparen_loc, buffer);
                }
                break;
            }
            case PM_MULTI_WRITE_NODE: {
                const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->lefts.size));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->rights.size));
                if (cast->lparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->lparen_loc, buffer);
                }
                if (cast->rparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->rparen_loc, buffer);
                }
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_NEXT_NODE: {
                const pm_next_node_t *cast = (const pm_next_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_NIL_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_NO_BLOCK_PARAMETER_NODE: {
                const pm_no_block_parameter_node_t *cast = (const pm_no_block_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_NO_KEYWORDS_PARAMETER_NODE: {
                const pm_no_keywords_parameter_node_t *cast = (const pm_no_keywords_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_NUMBERED_PARAMETERS_NODE: {
                const pm_numbered_parameters_node_t *cast = (const pm_numbered_parameters_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_byte(buffer, cast->maximum);
                break;
            }
            case PM_NUMBERED_REFERENCE_READ_NODE: {
                const pm_numbered_reference_read_node_t *cast = (const pm_numbered_reference_read_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, cast->number);
                break;
            }
            case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
                const pm_optional_keyword_parameter_node_t *cast = (const pm_optional_keyword_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                break;
            }
            case PM_OPTIONAL_PARAMETER_NODE: {
                const pm_optional_parameter_node_t *cast = (const pm_optional_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_OR_NODE: {
                const pm_or_node_t *cast = (const pm_or_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_PARAMETERS_NODE: {
                const pm_parameters_node_t *cast = (const pm_parameters_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->requireds.size));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->optionals.size));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->posts.size));
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->keywords.size));
                break;
            }
            case PM_PARENTHESES_NODE: {
                const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_PINNED_EXPRESSION_NODE: {
                const pm_pinned_expression_node_t *cast = (const pm_pinned_expression_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                pm_serialize_location(&cast->lparen_loc, buffer);
                pm_serialize_location(&cast->rparen_loc, buffer);
                break;
            }
            case PM_PINNED_VARIABLE_NODE: {
                const pm_pinned_variable_node_t *cast = (const pm_pinned_variable_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_POST_EXECUTION_NODE: {
                const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_PRE_EXECUTION_NODE: {
                const pm_pre_execution_node_t *cast = (const pm_pre_execution_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                break;
            }
            case PM_PROGRAM_NODE: {
                const pm_program_node_t *cast = (const pm_program_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
                for (size_t index = 0; index < cast->locals.size; index++) {
                    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
                }
                break;
            }
            case PM_RANGE_NODE: {
                const pm_range_node_t *cast = (const pm_range_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_RATIONAL_NODE: {
                const pm_rational_node_t *cast = (const pm_rational_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_integer(&cast->numerator, buffer);
                pm_serialize_integer(&cast->denominator, buffer);
                break;
            }
            case PM_REDO_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_REGULAR_EXPRESSION_NODE: {
                const pm_regular_expression_node_t *cast = (const pm_regular_expression_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->content_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                pm_serialize_string(&cast->unescaped, buffer);
                break;
            }
            case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
                const pm_required_keyword_parameter_node_t *cast = (const pm_required_keyword_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                pm_serialize_location(&cast->name_loc, buffer);
                break;
            }
            case PM_REQUIRED_PARAMETER_NODE: {
                const pm_required_parameter_node_t *cast = (const pm_required_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                break;
            }
            case PM_RESCUE_MODIFIER_NODE: {
                const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_RESCUE_NODE: {
                const pm_rescue_node_t *cast = (const pm_rescue_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->exceptions.size));
                if (cast->operator_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->operator_loc, buffer);
                }
                if (cast->then_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->then_keyword_loc, buffer);
                }
                break;
            }
            case PM_REST_PARAMETER_NODE: {
                const pm_rest_parameter_node_t *cast = (const pm_rest_parameter_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
                if (cast->name_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->name_loc, buffer);
                }
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_RETRY_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_RETURN_NODE: {
                const pm_return_node_t *cast = (const pm_return_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_SELF_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_SHAREABLE_CONSTANT_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_SINGLETON_CLASS_NODE: {
                const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
                for (size_t index = 0; index < cast->locals.size; index++) {
                    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
                }
                pm_serialize_location(&cast->class_keyword_loc, buffer);
                pm_serialize_location(&cast->operator_loc, buffer);
                pm_serialize_location(&cast->end_keyword_loc, buffer);
                break;
            }
            case PM_SOURCE_ENCODING_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_SOURCE_FILE_NODE: {
                const pm_source_file_node_t *cast = (const pm_source_file_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_string(&cast->filepath, buffer);
                break;
            }
            case PM_SOURCE_LINE_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_SPLAT_NODE: {
                const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->operator_loc, buffer);
                break;
            }
            case PM_STATEMENTS_NODE: {
                const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->body.size));
                break;
            }
            case PM_STRING_NODE: {
                const pm_string_node_t *cast = (const pm_string_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                pm_serialize_location(&cast->content_loc, buffer);
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                pm_serialize_string(&cast->unescaped, buffer);
                break;
            }
            case PM_SUPER_NODE: {
                const pm_super_node_t *cast = (const pm_super_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                if (cast->lparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->lparen_loc, buffer);
                }
                if (cast->rparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->rparen_loc, buffer);
                }
                break;
            }
            case PM_SYMBOL_NODE: {
                const pm_symbol_node_t *cast = (const pm_symbol_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                if (cast->opening_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->opening_loc, buffer);
                }
                pm_serialize_location(&cast->content_loc, buffer);
                if (cast->closing_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->closing_loc, buffer);
                }
                pm_serialize_string(&cast->unescaped, buffer);
                break;
            }
            case PM_TRUE_NODE: {
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                break;
            }
            case PM_UNDEF_NODE: {
                const pm_undef_node_t *cast = (const pm_undef_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->names.size));
                pm_serialize_location(&cast->keyword_loc, buffer);
                break;
            }
            case PM_UNLESS_NODE: {
                const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->unless_keyword_loc, buffer);
                if (cast->then_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->then_keyword_loc, buffer);
                }
                if (cast->end_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->end_keyword_loc, buffer);
                }
                break;
            }
            case PM_UNTIL_NODE: {
                const pm_until_node_t *cast = (const pm_until_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->until_keyword_loc, buffer);
                if (cast->do_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->do_keyword_loc, buffer);
                }
                if (cast->end_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->end_keyword_loc, buffer);
                }
                break;
            }
            case PM_WHEN_NODE: {
                const pm_when_node_t *cast = (const pm_when_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->when_keyword_loc, buffer);
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->conditions.size));
                if (cast->then_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->then_keyword_loc, buffer);
                }
                break;
            }
            case PM_WHILE_NODE: {
                const pm_while_node_t *cast = (const pm_while_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->while_keyword_loc, buffer);
                if (cast->do_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->do_keyword_loc, buffer);
                }
                if (cast->end_keyword_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->end_keyword_loc, buffer);
                }
                break;
            }
            case PM_X_STRING_NODE: {
                const pm_x_string_node_t *cast = (const pm_x_string_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->opening_loc, buffer);
                pm_serialize_location(&cast->content_loc, buffer);
                pm_serialize_location(&cast->closing_loc, buffer);
                pm_serialize_string(&cast->unescaped, buffer);
                break;
            }
            case PM_YIELD_NODE: {
                const pm_yield_node_t *cast = (const pm_yield_node_t *) node;
                pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
                pm_serialize_location(&cast->keyword_loc, buffer);
                if (cast->lparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->lparen_loc, buffer);
                }
                if (cast->rparen_loc.length == 0) {
                    pm_buffer_append_byte(buffer, 0);
                } else {
                    pm_buffer_append_byte(buffer, 1);
                    pm_serialize_location(&cast->rparen_loc, buffer);
                }
                break;
            }
        }
    }
 
    xfree_sized(stack.entries, stack.capacity * sizeof(pm_serialize_entry_t));
}
 
/*
 * Serialize the given list of offsets to the given buffer.
 */
void
pm_serialize_line_offset_list(pm_line_offset_list_t *list, pm_buffer_t *buffer) {
    uint32_t size = pm_sizet_to_u32(list->size);
    pm_buffer_append_varuint(buffer, size);
 
    for (uint32_t i = 0; i < size; i++) {
        uint32_t offset = pm_sizet_to_u32(list->offsets[i]);
        pm_buffer_append_varuint(buffer, offset);
    }
}
 
static void
pm_serialize_comment(pm_comment_t *comment, pm_buffer_t *buffer) {
    // serialize type
    pm_buffer_append_byte(buffer, (uint8_t) comment->type);
 
    // serialize location
    pm_serialize_location(&comment->location, buffer);
}
 
void
pm_serialize_comment_list(pm_list_t *list, pm_buffer_t *buffer) {
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
 
    pm_comment_t *comment;
    for (comment = (pm_comment_t *) list->head; comment != NULL; comment = (pm_comment_t *) comment->node.next) {
        pm_serialize_comment(comment, buffer);
    }
}
 
static void
pm_serialize_comment_attachments(const pm_comment_attachments_t *attachments, pm_buffer_t *buffer) {
    uint32_t count = 0;
    for (uint32_t node_id = 0; node_id < attachments->ranges_size; node_id++) {
        if (attachments->ranges[node_id].length > 0) count++;
    }
 
    pm_buffer_append_varuint(buffer, count);
 
    for (uint32_t node_id = 0; node_id < attachments->ranges_size; node_id++) {
        pm_comment_range_t range = attachments->ranges[node_id];
        if (range.length == 0) continue;
 
        pm_buffer_append_varuint(buffer, node_id);
        pm_buffer_append_varuint(buffer, range.length);
 
        for (uint32_t index = 0; index < range.length; index++) {
            pm_buffer_append_varuint(buffer, attachments->attachments[range.index + index]);
        }
    }
}
 
static void
pm_serialize_magic_comment(pm_magic_comment_t *magic_comment, pm_buffer_t *buffer) {
    // serialize key location
    pm_buffer_append_varuint(buffer, magic_comment->key.start);
    pm_buffer_append_varuint(buffer, magic_comment->key.length);
 
    // serialize value location
    pm_buffer_append_varuint(buffer, magic_comment->value.start);
    pm_buffer_append_varuint(buffer, magic_comment->value.length);
}
 
static void
pm_serialize_magic_comment_list(pm_list_t *list, pm_buffer_t *buffer) {
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
 
    pm_magic_comment_t *magic_comment;
    for (magic_comment = (pm_magic_comment_t *) list->head; magic_comment != NULL; magic_comment = (pm_magic_comment_t *) magic_comment->node.next) {
        pm_serialize_magic_comment(magic_comment, buffer);
    }
}
 
static void
pm_serialize_data_loc(const pm_parser_t *parser, pm_buffer_t *buffer) {
    if (parser->data_loc.length == 0) {
        pm_buffer_append_byte(buffer, 0);
    } else {
        pm_buffer_append_byte(buffer, 1);
        pm_serialize_location(&parser->data_loc, buffer);
    }
}
 
static void
pm_serialize_diagnostic(pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) {
    // serialize the type
    pm_buffer_append_varuint(buffer, (uint32_t) diagnostic->diag_id);
 
    // serialize message
    size_t message_length = strlen(diagnostic->message);
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(message_length));
    pm_buffer_append_string(buffer, diagnostic->message, message_length);
 
    // serialize location
    pm_serialize_location(&diagnostic->location, buffer);
 
    pm_buffer_append_byte(buffer, diagnostic->level);
}
 
static void
pm_serialize_diagnostic_list(pm_list_t *list, pm_buffer_t *buffer) {
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
 
    pm_diagnostic_t *diagnostic;
    for (diagnostic = (pm_diagnostic_t *) list->head; diagnostic != NULL; diagnostic = (pm_diagnostic_t *) diagnostic->node.next) {
        pm_serialize_diagnostic(diagnostic, buffer);
    }
}
 
void
pm_serialize_encoding(const pm_encoding_t *encoding, pm_buffer_t *buffer) {
    size_t encoding_length = strlen(encoding->name);
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(encoding_length));
    pm_buffer_append_string(buffer, encoding->name, encoding_length);
}
 
static void
pm_serialize_metadata(pm_parser_t *parser, pm_buffer_t *buffer) {
    pm_serialize_encoding(parser->encoding, buffer);
    pm_buffer_append_varsint(buffer, parser->start_line);
    pm_buffer_append_uint64(buffer, pm_parser_checksum(parser));
    pm_serialize_line_offset_list(&parser->line_offsets, buffer);
    pm_serialize_comment_list(&parser->comment_list, buffer);
    pm_serialize_comment_attachments(&parser->comment_attachments, buffer);
    pm_serialize_magic_comment_list(&parser->magic_comment_list, buffer);
    pm_serialize_data_loc(parser, buffer);
    pm_serialize_diagnostic_list(&parser->error_list, buffer);
    pm_serialize_diagnostic_list(&parser->warning_list, buffer);
    pm_buffer_append_byte(buffer, (uint8_t) parser->continuable);
}
 
#line 463 "prism/templates/src/serialize.c.erb"
void
pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
    pm_serialize_metadata(parser, buffer);
 
    // Here we're going to leave space for the offset of the constant pool in
    // the buffer.
    size_t offset = buffer->length;
    pm_buffer_append_zeroes(buffer, 4);
 
    // Next, encode the length of the constant pool.
    pm_buffer_append_varuint(buffer, parser->constant_pool.size);
 
    // Now we're going to serialize the content of the node.
    pm_serialize_node(node, buffer);
 
    // Now we're going to serialize the offset of the constant pool back where
    // we left space for it.
    uint32_t length = pm_sizet_to_u32(buffer->length);
    memcpy(buffer->value + offset, &length, sizeof(uint32_t));
 
    // Now we're going to serialize the constant pool.
    offset = buffer->length;
    pm_buffer_append_zeroes(buffer, parser->constant_pool.size * 8);
 
    for (uint32_t index = 0; index < parser->constant_pool.capacity; index++) {
        pm_constant_pool_bucket_t *bucket = &parser->constant_pool.buckets[index];
 
        // If we find a constant at this index, serialize it at the correct
        // index in the buffer.
        if (bucket->id != 0) {
            pm_constant_t *constant = &parser->constant_pool.constants[bucket->id - 1];
            size_t buffer_offset = offset + ((((size_t)bucket->id) - 1) * 8);
 
            // Write the constant contents into the buffer after the constant
            // pool. In place of the source offset, we store a buffer offset.
            uint32_t content_offset = pm_sizet_to_u32(buffer->length);
            memcpy(buffer->value + buffer_offset, &content_offset, 4);
            pm_buffer_append_bytes(buffer, constant->start, constant->length);
 
            uint32_t constant_length = pm_sizet_to_u32(constant->length);
            memcpy(buffer->value + buffer_offset + 4, &constant_length, 4);
        }
    }
}
 
static void
serialize_token(pm_parser_t *parser, pm_token_t *token, void *data) {
    pm_buffer_t *buffer = (pm_buffer_t *) data;
 
    pm_buffer_append_varuint(buffer, token->type);
    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->start - parser->start));
    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
    pm_buffer_append_varuint(buffer, parser->lex_state);
}
 
void
pm_serialize_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
    pm_options_t options = { 0 };
    pm_options_read(&options, data);
 
    pm_arena_t arena = { 0 };
    pm_parser_t parser;
    pm_parser_init(&arena, &parser, source, size, &options);
 
    pm_parser_lex_callback_set(&parser, serialize_token, buffer);
    pm_parse(&parser);
 
    // Append 0 to mark end of tokens.
    pm_buffer_append_byte(buffer, 0);
 
    pm_serialize_metadata(&parser, buffer);
 
    pm_parser_cleanup(&parser);
    pm_arena_cleanup(&arena);
    pm_options_cleanup(&options);
}
 
void
pm_serialize_parse_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
    pm_options_t options = { 0 };
    pm_options_read(&options, data);
 
    pm_arena_t arena = { 0 };
    pm_parser_t parser;
    pm_parser_init(&arena, &parser, source, size, &options);
 
    pm_parser_lex_callback_set(&parser, serialize_token, buffer);
    pm_node_t *node = pm_parse(&parser);
 
    pm_buffer_append_byte(buffer, 0);
    pm_serialize(&parser, node, buffer);
 
    pm_parser_cleanup(&parser);
    pm_arena_cleanup(&arena);
    pm_options_cleanup(&options);
}
 
bool
pm_serialize_parse_success_p(const uint8_t *source, size_t size, const char *data) {
    pm_options_t options = { 0 };
    pm_options_read(&options, data);
 
    pm_arena_t arena = { 0 };
    pm_parser_t parser;
    pm_parser_init(&arena, &parser, source, size, &options);
 
    pm_parse(&parser);
 
    bool result = parser.error_list.size == 0;
    pm_parser_cleanup(&parser);
    pm_arena_cleanup(&arena);
    pm_options_cleanup(&options);
 
    return result;
}
 
#endif