prism 1.9.0 → 2.0.0.rc2

data/src/serialize.c

@@ -1,5 +1,3 @@
-/* :markup: markdown */
-
 /*----------------------------------------------------------------------------*/
 /* This file is generated by the templates/template.rb script and should not  */
 /* be modified manually. See                                                  */
@@ -8,60 +6,61 @@
 /* template                                                                   */
 /*----------------------------------------------------------------------------*/
 
-#include "prism.h"
+#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
 
-// We optionally support serializing to a binary string. For systems that don't
-// want or need this functionality, it can be turned off with the
-// PRISM_EXCLUDE_SERIALIZATION define.
-#ifndef PRISM_EXCLUDE_SERIALIZATION
+#include "prism/compiler/inline.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 <stdio.h>
+#include <string.h>
 
-static inline uint32_t
+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 inline uint32_t
+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_parser_t *parser, const pm_location_t *location, pm_buffer_t *buffer) {
-    assert(location->start);
-    assert(location->end);
-    assert(location->start <= location->end);
-
-    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->start - parser->start));
-    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->end - location->start));
+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_parser_t *parser, const pm_string_t *string, pm_buffer_t *buffer) {
-    switch (string->type) {
-        case PM_STRING_SHARED: {
-            pm_buffer_append_byte(buffer, 1);
-            pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(pm_string_source(string) - parser->start));
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_string_length(string)));
-            break;
-        }
-        case PM_STRING_OWNED:
-        case PM_STRING_CONSTANT: {
-            uint32_t length = pm_sizet_to_u32(pm_string_length(string));
-            pm_buffer_append_byte(buffer, 2);
-            pm_buffer_append_varuint(buffer, length);
-            pm_buffer_append_bytes(buffer, pm_string_source(string), length);
-            break;
-        }
-#ifdef PRISM_HAS_MMAP
-        case PM_STRING_MAPPED:
-            assert(false && "Cannot serialize mapped strings.");
-            break;
-#endif
-    }
+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
@@ -82,10 +81,8 @@ static void
 pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
     pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node));
 
-    size_t offset = buffer->length;
-
     pm_buffer_append_varuint(buffer, node->node_id);
-    pm_serialize_location(parser, &node->location, buffer);
+    pm_serialize_location(&node->location, buffer);
 
     switch (PM_NODE_TYPE(node)) {
         // We do not need to serialize a ScopeNode ever as
@@ -96,28 +93,28 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_alias_global_variable_node_t *)node)->new_name, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_alias_global_variable_node_t *)node)->old_name, buffer);
-            pm_serialize_location(parser, &((pm_alias_global_variable_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_alias_global_variable_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case PM_ALIAS_METHOD_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_alias_method_node_t *)node)->new_name, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_alias_method_node_t *)node)->old_name, buffer);
-            pm_serialize_location(parser, &((pm_alias_method_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_alias_method_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case PM_ALTERNATION_PATTERN_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_alternation_pattern_node_t *)node)->left, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_alternation_pattern_node_t *)node)->right, buffer);
-            pm_serialize_location(parser, &((pm_alternation_pattern_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_alternation_pattern_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_AND_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_and_node_t *)node)->left, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_and_node_t *)node)->right, buffer);
-            pm_serialize_location(parser, &((pm_and_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_and_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_ARGUMENTS_NODE: {
@@ -136,17 +133,17 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < elements_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_array_node_t *)node)->elements.nodes[index], buffer);
             }
-            if (((pm_array_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_array_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_array_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_array_node_t *)node)->opening_loc, buffer);
             }
-            if (((pm_array_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_array_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_array_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_array_node_t *)node)->closing_loc, buffer);
             }
             break;
         }
@@ -172,17 +169,17 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < posts_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_array_pattern_node_t *)node)->posts.nodes[index], buffer);
             }
-            if (((pm_array_pattern_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_array_pattern_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_array_pattern_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_array_pattern_node_t *)node)->opening_loc, buffer);
             }
-            if (((pm_array_pattern_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_array_pattern_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_array_pattern_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_array_pattern_node_t *)node)->closing_loc, buffer);
             }
             break;
         }
@@ -190,11 +187,11 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_assoc_node_t *)node)->key, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_assoc_node_t *)node)->value, buffer);
-            if (((pm_assoc_node_t *)node)->operator_loc.start == NULL) {
+            if (((pm_assoc_node_t *)node)->operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_assoc_node_t *)node)->operator_loc, buffer);
+                pm_serialize_location(&((pm_assoc_node_t *)node)->operator_loc, buffer);
             }
             break;
         }
@@ -205,7 +202,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_assoc_splat_node_t *)node)->value, buffer);
             }
-            pm_serialize_location(parser, &((pm_assoc_splat_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_assoc_splat_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_BACK_REFERENCE_READ_NODE: {
@@ -215,11 +212,11 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_BEGIN_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            if (((pm_begin_node_t *)node)->begin_keyword_loc.start == NULL) {
+            if (((pm_begin_node_t *)node)->begin_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_begin_node_t *)node)->begin_keyword_loc, buffer);
+                pm_serialize_location(&((pm_begin_node_t *)node)->begin_keyword_loc, buffer);
             }
             if (((pm_begin_node_t *)node)->statements == NULL) {
                 pm_buffer_append_byte(buffer, 0);
@@ -241,11 +238,11 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_begin_node_t *)node)->ensure_clause, buffer);
             }
-            if (((pm_begin_node_t *)node)->end_keyword_loc.start == NULL) {
+            if (((pm_begin_node_t *)node)->end_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_begin_node_t *)node)->end_keyword_loc, buffer);
+                pm_serialize_location(&((pm_begin_node_t *)node)->end_keyword_loc, buffer);
             }
             break;
         }
@@ -256,7 +253,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_block_argument_node_t *)node)->expression, buffer);
             }
-            pm_serialize_location(parser, &((pm_block_argument_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_block_argument_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_BLOCK_LOCAL_VARIABLE_NODE: {
@@ -281,20 +278,20 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_block_node_t *)node)->body, buffer);
             }
-            pm_serialize_location(parser, &((pm_block_node_t *)node)->opening_loc, buffer);
-            pm_serialize_location(parser, &((pm_block_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_block_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_block_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_BLOCK_PARAMETER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_block_parameter_node_t *)node)->name));
-            if (((pm_block_parameter_node_t *)node)->name_loc.start == NULL) {
+            if (((pm_block_parameter_node_t *)node)->name_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_block_parameter_node_t *)node)->name_loc, buffer);
+                pm_serialize_location(&((pm_block_parameter_node_t *)node)->name_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_block_parameter_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_block_parameter_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_BLOCK_PARAMETERS_NODE: {
@@ -309,17 +306,17 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < locals_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_block_parameters_node_t *)node)->locals.nodes[index], buffer);
             }
-            if (((pm_block_parameters_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_block_parameters_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_block_parameters_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_block_parameters_node_t *)node)->opening_loc, buffer);
             }
-            if (((pm_block_parameters_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_block_parameters_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_block_parameters_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_block_parameters_node_t *)node)->closing_loc, buffer);
             }
             break;
         }
@@ -330,7 +327,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_break_node_t *)node)->arguments, buffer);
             }
-            pm_serialize_location(parser, &((pm_break_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_break_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case PM_CALL_AND_WRITE_NODE: {
@@ -340,21 +337,21 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_call_and_write_node_t *)node)->receiver, buffer);
             }
-            if (((pm_call_and_write_node_t *)node)->call_operator_loc.start == NULL) {
+            if (((pm_call_and_write_node_t *)node)->call_operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_and_write_node_t *)node)->call_operator_loc, buffer);
+                pm_serialize_location(&((pm_call_and_write_node_t *)node)->call_operator_loc, buffer);
             }
-            if (((pm_call_and_write_node_t *)node)->message_loc.start == NULL) {
+            if (((pm_call_and_write_node_t *)node)->message_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_and_write_node_t *)node)->message_loc, buffer);
+                pm_serialize_location(&((pm_call_and_write_node_t *)node)->message_loc, buffer);
             }
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_and_write_node_t *)node)->read_name));
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_and_write_node_t *)node)->write_name));
-            pm_serialize_location(parser, &((pm_call_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_call_and_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_call_and_write_node_t *)node)->value, buffer);
             break;
         }
@@ -365,41 +362,41 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_call_node_t *)node)->receiver, buffer);
             }
-            if (((pm_call_node_t *)node)->call_operator_loc.start == NULL) {
+            if (((pm_call_node_t *)node)->call_operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_node_t *)node)->call_operator_loc, buffer);
+                pm_serialize_location(&((pm_call_node_t *)node)->call_operator_loc, buffer);
             }
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_node_t *)node)->name));
-            if (((pm_call_node_t *)node)->message_loc.start == NULL) {
+            if (((pm_call_node_t *)node)->message_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_node_t *)node)->message_loc, buffer);
+                pm_serialize_location(&((pm_call_node_t *)node)->message_loc, buffer);
             }
-            if (((pm_call_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_call_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_call_node_t *)node)->opening_loc, buffer);
             }
             if (((pm_call_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_call_node_t *)node)->arguments, buffer);
             }
-            if (((pm_call_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_call_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_call_node_t *)node)->closing_loc, buffer);
             }
-            if (((pm_call_node_t *)node)->equal_loc.start == NULL) {
+            if (((pm_call_node_t *)node)->equal_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_node_t *)node)->equal_loc, buffer);
+                pm_serialize_location(&((pm_call_node_t *)node)->equal_loc, buffer);
             }
             if (((pm_call_node_t *)node)->block == NULL) {
                 pm_buffer_append_byte(buffer, 0);
@@ -415,22 +412,22 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_call_operator_write_node_t *)node)->receiver, buffer);
             }
-            if (((pm_call_operator_write_node_t *)node)->call_operator_loc.start == NULL) {
+            if (((pm_call_operator_write_node_t *)node)->call_operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_operator_write_node_t *)node)->call_operator_loc, buffer);
+                pm_serialize_location(&((pm_call_operator_write_node_t *)node)->call_operator_loc, buffer);
             }
-            if (((pm_call_operator_write_node_t *)node)->message_loc.start == NULL) {
+            if (((pm_call_operator_write_node_t *)node)->message_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_operator_write_node_t *)node)->message_loc, buffer);
+                pm_serialize_location(&((pm_call_operator_write_node_t *)node)->message_loc, buffer);
             }
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->read_name));
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->write_name));
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->binary_operator));
-            pm_serialize_location(parser, &((pm_call_operator_write_node_t *)node)->binary_operator_loc, buffer);
+            pm_serialize_location(&((pm_call_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_call_operator_write_node_t *)node)->value, buffer);
             break;
         }
@@ -441,37 +438,37 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_call_or_write_node_t *)node)->receiver, buffer);
             }
-            if (((pm_call_or_write_node_t *)node)->call_operator_loc.start == NULL) {
+            if (((pm_call_or_write_node_t *)node)->call_operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_or_write_node_t *)node)->call_operator_loc, buffer);
+                pm_serialize_location(&((pm_call_or_write_node_t *)node)->call_operator_loc, buffer);
             }
-            if (((pm_call_or_write_node_t *)node)->message_loc.start == NULL) {
+            if (((pm_call_or_write_node_t *)node)->message_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_or_write_node_t *)node)->message_loc, buffer);
+                pm_serialize_location(&((pm_call_or_write_node_t *)node)->message_loc, buffer);
             }
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_or_write_node_t *)node)->read_name));
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_or_write_node_t *)node)->write_name));
-            pm_serialize_location(parser, &((pm_call_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_call_or_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_call_or_write_node_t *)node)->value, buffer);
             break;
         }
         case PM_CALL_TARGET_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_call_target_node_t *)node)->receiver, buffer);
-            pm_serialize_location(parser, &((pm_call_target_node_t *)node)->call_operator_loc, buffer);
+            pm_serialize_location(&((pm_call_target_node_t *)node)->call_operator_loc, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_target_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_call_target_node_t *)node)->message_loc, buffer);
+            pm_serialize_location(&((pm_call_target_node_t *)node)->message_loc, buffer);
             break;
         }
         case PM_CAPTURE_PATTERN_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_capture_pattern_node_t *)node)->value, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_capture_pattern_node_t *)node)->target, buffer);
-            pm_serialize_location(parser, &((pm_capture_pattern_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_capture_pattern_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_CASE_MATCH_NODE: {
@@ -491,8 +488,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_case_match_node_t *)node)->else_clause, buffer);
             }
-            pm_serialize_location(parser, &((pm_case_match_node_t *)node)->case_keyword_loc, buffer);
-            pm_serialize_location(parser, &((pm_case_match_node_t *)node)->end_keyword_loc, buffer);
+            pm_serialize_location(&((pm_case_match_node_t *)node)->case_keyword_loc, buffer);
+            pm_serialize_location(&((pm_case_match_node_t *)node)->end_keyword_loc, buffer);
             break;
         }
         case PM_CASE_NODE: {
@@ -512,8 +509,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_case_node_t *)node)->else_clause, buffer);
             }
-            pm_serialize_location(parser, &((pm_case_node_t *)node)->case_keyword_loc, buffer);
-            pm_serialize_location(parser, &((pm_case_node_t *)node)->end_keyword_loc, buffer);
+            pm_serialize_location(&((pm_case_node_t *)node)->case_keyword_loc, buffer);
+            pm_serialize_location(&((pm_case_node_t *)node)->end_keyword_loc, buffer);
             break;
         }
         case PM_CLASS_NODE: {
@@ -523,13 +520,13 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < locals_size; index++) {
                 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_node_t *)node)->locals.ids[index]));
             }
-            pm_serialize_location(parser, &((pm_class_node_t *)node)->class_keyword_loc, buffer);
+            pm_serialize_location(&((pm_class_node_t *)node)->class_keyword_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_class_node_t *)node)->constant_path, buffer);
-            if (((pm_class_node_t *)node)->inheritance_operator_loc.start == NULL) {
+            if (((pm_class_node_t *)node)->inheritance_operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_class_node_t *)node)->inheritance_operator_loc, buffer);
+                pm_serialize_location(&((pm_class_node_t *)node)->inheritance_operator_loc, buffer);
             }
             if (((pm_class_node_t *)node)->superclass == NULL) {
                 pm_buffer_append_byte(buffer, 0);
@@ -541,23 +538,23 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_class_node_t *)node)->body, buffer);
             }
-            pm_serialize_location(parser, &((pm_class_node_t *)node)->end_keyword_loc, buffer);
+            pm_serialize_location(&((pm_class_node_t *)node)->end_keyword_loc, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_node_t *)node)->name));
             break;
         }
         case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_and_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_class_variable_and_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_class_variable_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_class_variable_and_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_class_variable_and_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_and_write_node_t *)node)->value, buffer);
             break;
         }
         case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_operator_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_class_variable_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_class_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
+            pm_serialize_location(&((pm_class_variable_operator_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_class_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_operator_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_operator_write_node_t *)node)->binary_operator));
             break;
@@ -565,8 +562,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_or_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_class_variable_or_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_class_variable_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_class_variable_or_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_class_variable_or_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_or_write_node_t *)node)->value, buffer);
             break;
         }
@@ -583,24 +580,24 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_CLASS_VARIABLE_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_class_variable_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_class_variable_write_node_t *)node)->name_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_write_node_t *)node)->value, buffer);
-            pm_serialize_location(parser, &((pm_class_variable_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_class_variable_write_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_CONSTANT_AND_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_and_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_constant_and_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_constant_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_constant_and_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_constant_and_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_and_write_node_t *)node)->value, buffer);
             break;
         }
         case PM_CONSTANT_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_operator_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_constant_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_constant_operator_write_node_t *)node)->binary_operator_loc, buffer);
+            pm_serialize_location(&((pm_constant_operator_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_constant_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_operator_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_operator_write_node_t *)node)->binary_operator));
             break;
@@ -608,15 +605,15 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_CONSTANT_OR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_or_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_constant_or_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_constant_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_constant_or_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_constant_or_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_or_write_node_t *)node)->value, buffer);
             break;
         }
         case PM_CONSTANT_PATH_AND_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_and_write_node_t *)node)->target, buffer);
-            pm_serialize_location(parser, &((pm_constant_path_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_constant_path_and_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_and_write_node_t *)node)->value, buffer);
             break;
         }
@@ -628,14 +625,14 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
                 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_node_t *)node)->parent, buffer);
             }
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_constant_path_node_t *)node)->delimiter_loc, buffer);
-            pm_serialize_location(parser, &((pm_constant_path_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_constant_path_node_t *)node)->delimiter_loc, buffer);
+            pm_serialize_location(&((pm_constant_path_node_t *)node)->name_loc, buffer);
             break;
         }
         case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_operator_write_node_t *)node)->target, buffer);
-            pm_serialize_location(parser, &((pm_constant_path_operator_write_node_t *)node)->binary_operator_loc, buffer);
+            pm_serialize_location(&((pm_constant_path_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_operator_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_operator_write_node_t *)node)->binary_operator));
             break;
@@ -643,7 +640,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_CONSTANT_PATH_OR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_or_write_node_t *)node)->target, buffer);
-            pm_serialize_location(parser, &((pm_constant_path_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_constant_path_or_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_or_write_node_t *)node)->value, buffer);
             break;
         }
@@ -655,14 +652,14 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
                 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_target_node_t *)node)->parent, buffer);
             }
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_target_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_constant_path_target_node_t *)node)->delimiter_loc, buffer);
-            pm_serialize_location(parser, &((pm_constant_path_target_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_constant_path_target_node_t *)node)->delimiter_loc, buffer);
+            pm_serialize_location(&((pm_constant_path_target_node_t *)node)->name_loc, buffer);
             break;
         }
         case PM_CONSTANT_PATH_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_write_node_t *)node)->target, buffer);
-            pm_serialize_location(parser, &((pm_constant_path_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_constant_path_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_write_node_t *)node)->value, buffer);
             break;
         }
@@ -679,9 +676,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_CONSTANT_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_constant_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_constant_write_node_t *)node)->name_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_write_node_t *)node)->value, buffer);
-            pm_serialize_location(parser, &((pm_constant_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_constant_write_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_DEF_NODE: {
@@ -691,7 +688,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             pm_buffer_append_string(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_def_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_def_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_def_node_t *)node)->name_loc, buffer);
             if (((pm_def_node_t *)node)->receiver == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
@@ -712,102 +709,111 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < locals_size; index++) {
                 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_def_node_t *)node)->locals.ids[index]));
             }
-            pm_serialize_location(parser, &((pm_def_node_t *)node)->def_keyword_loc, buffer);
-            if (((pm_def_node_t *)node)->operator_loc.start == NULL) {
+            pm_serialize_location(&((pm_def_node_t *)node)->def_keyword_loc, buffer);
+            if (((pm_def_node_t *)node)->operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_def_node_t *)node)->operator_loc, buffer);
+                pm_serialize_location(&((pm_def_node_t *)node)->operator_loc, buffer);
             }
-            if (((pm_def_node_t *)node)->lparen_loc.start == NULL) {
+            if (((pm_def_node_t *)node)->lparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_def_node_t *)node)->lparen_loc, buffer);
+                pm_serialize_location(&((pm_def_node_t *)node)->lparen_loc, buffer);
             }
-            if (((pm_def_node_t *)node)->rparen_loc.start == NULL) {
+            if (((pm_def_node_t *)node)->rparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_def_node_t *)node)->rparen_loc, buffer);
+                pm_serialize_location(&((pm_def_node_t *)node)->rparen_loc, buffer);
             }
-            if (((pm_def_node_t *)node)->equal_loc.start == NULL) {
+            if (((pm_def_node_t *)node)->equal_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_def_node_t *)node)->equal_loc, buffer);
+                pm_serialize_location(&((pm_def_node_t *)node)->equal_loc, buffer);
             }
-            if (((pm_def_node_t *)node)->end_keyword_loc.start == NULL) {
+            if (((pm_def_node_t *)node)->end_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_def_node_t *)node)->end_keyword_loc, buffer);
+                pm_serialize_location(&((pm_def_node_t *)node)->end_keyword_loc, buffer);
             }
             // serialize length
-            uint32_t length = pm_sizet_to_u32(buffer->length - offset - sizeof(uint32_t));
+            uint32_t length = pm_sizet_to_u32(buffer->length - length_offset);
             memcpy(buffer->value + length_offset, &length, sizeof(uint32_t));
             break;
         }
         case PM_DEFINED_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            if (((pm_defined_node_t *)node)->lparen_loc.start == NULL) {
+            if (((pm_defined_node_t *)node)->lparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_defined_node_t *)node)->lparen_loc, buffer);
+                pm_serialize_location(&((pm_defined_node_t *)node)->lparen_loc, buffer);
             }
             pm_serialize_node(parser, (pm_node_t *)((pm_defined_node_t *)node)->value, buffer);
-            if (((pm_defined_node_t *)node)->rparen_loc.start == NULL) {
+            if (((pm_defined_node_t *)node)->rparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_defined_node_t *)node)->rparen_loc, buffer);
+                pm_serialize_location(&((pm_defined_node_t *)node)->rparen_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_defined_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_defined_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case PM_ELSE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_else_node_t *)node)->else_keyword_loc, buffer);
+            pm_serialize_location(&((pm_else_node_t *)node)->else_keyword_loc, buffer);
             if (((pm_else_node_t *)node)->statements == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_else_node_t *)node)->statements, buffer);
             }
-            if (((pm_else_node_t *)node)->end_keyword_loc.start == NULL) {
+            if (((pm_else_node_t *)node)->end_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_else_node_t *)node)->end_keyword_loc, buffer);
+                pm_serialize_location(&((pm_else_node_t *)node)->end_keyword_loc, buffer);
             }
             break;
         }
         case PM_EMBEDDED_STATEMENTS_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_embedded_statements_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_embedded_statements_node_t *)node)->opening_loc, buffer);
             if (((pm_embedded_statements_node_t *)node)->statements == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_embedded_statements_node_t *)node)->statements, buffer);
             }
-            pm_serialize_location(parser, &((pm_embedded_statements_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_embedded_statements_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_EMBEDDED_VARIABLE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_embedded_variable_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_embedded_variable_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_embedded_variable_node_t *)node)->variable, buffer);
             break;
         }
         case PM_ENSURE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_ensure_node_t *)node)->ensure_keyword_loc, buffer);
+            pm_serialize_location(&((pm_ensure_node_t *)node)->ensure_keyword_loc, buffer);
             if (((pm_ensure_node_t *)node)->statements == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_ensure_node_t *)node)->statements, buffer);
             }
-            pm_serialize_location(parser, &((pm_ensure_node_t *)node)->end_keyword_loc, buffer);
+            pm_serialize_location(&((pm_ensure_node_t *)node)->end_keyword_loc, buffer);
+            break;
+        }
+        case PM_ERROR_RECOVERY_NODE: {
+            pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
+            if (((pm_error_recovery_node_t *)node)->unexpected == NULL) {
+                pm_buffer_append_byte(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_error_recovery_node_t *)node)->unexpected, buffer);
+            }
             break;
         }
         case PM_FALSE_NODE: {
@@ -828,17 +834,17 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_find_pattern_node_t *)node)->requireds.nodes[index], buffer);
             }
             pm_serialize_node(parser, (pm_node_t *)((pm_find_pattern_node_t *)node)->right, buffer);
-            if (((pm_find_pattern_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_find_pattern_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_find_pattern_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_find_pattern_node_t *)node)->opening_loc, buffer);
             }
-            if (((pm_find_pattern_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_find_pattern_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_find_pattern_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_find_pattern_node_t *)node)->closing_loc, buffer);
             }
             break;
         }
@@ -854,7 +860,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_flip_flop_node_t *)node)->right, buffer);
             }
-            pm_serialize_location(parser, &((pm_flip_flop_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_flip_flop_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_FLOAT_NODE: {
@@ -871,15 +877,15 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_for_node_t *)node)->statements, buffer);
             }
-            pm_serialize_location(parser, &((pm_for_node_t *)node)->for_keyword_loc, buffer);
-            pm_serialize_location(parser, &((pm_for_node_t *)node)->in_keyword_loc, buffer);
-            if (((pm_for_node_t *)node)->do_keyword_loc.start == NULL) {
+            pm_serialize_location(&((pm_for_node_t *)node)->for_keyword_loc, buffer);
+            pm_serialize_location(&((pm_for_node_t *)node)->in_keyword_loc, buffer);
+            if (((pm_for_node_t *)node)->do_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_for_node_t *)node)->do_keyword_loc, buffer);
+                pm_serialize_location(&((pm_for_node_t *)node)->do_keyword_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_for_node_t *)node)->end_keyword_loc, buffer);
+            pm_serialize_location(&((pm_for_node_t *)node)->end_keyword_loc, buffer);
             break;
         }
         case PM_FORWARDING_ARGUMENTS_NODE: {
@@ -892,6 +898,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_FORWARDING_SUPER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
+            pm_serialize_location(&((pm_forwarding_super_node_t *)node)->keyword_loc, buffer);
             if (((pm_forwarding_super_node_t *)node)->block == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
@@ -902,16 +909,16 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_and_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_global_variable_and_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_global_variable_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_global_variable_and_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_global_variable_and_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_and_write_node_t *)node)->value, buffer);
             break;
         }
         case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_operator_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_global_variable_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_global_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
+            pm_serialize_location(&((pm_global_variable_operator_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_global_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_operator_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_operator_write_node_t *)node)->binary_operator));
             break;
@@ -919,8 +926,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_or_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_global_variable_or_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_global_variable_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_global_variable_or_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_global_variable_or_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_or_write_node_t *)node)->value, buffer);
             break;
         }
@@ -937,20 +944,20 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_GLOBAL_VARIABLE_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_global_variable_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_global_variable_write_node_t *)node)->name_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_write_node_t *)node)->value, buffer);
-            pm_serialize_location(parser, &((pm_global_variable_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_global_variable_write_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_HASH_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_hash_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_hash_node_t *)node)->opening_loc, buffer);
             uint32_t elements_size = pm_sizet_to_u32(((pm_hash_node_t *)node)->elements.size);
             pm_buffer_append_varuint(buffer, elements_size);
             for (uint32_t index = 0; index < elements_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_hash_node_t *)node)->elements.nodes[index], buffer);
             }
-            pm_serialize_location(parser, &((pm_hash_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_hash_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_HASH_PATTERN_NODE: {
@@ -970,34 +977,34 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_hash_pattern_node_t *)node)->rest, buffer);
             }
-            if (((pm_hash_pattern_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_hash_pattern_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_hash_pattern_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_hash_pattern_node_t *)node)->opening_loc, buffer);
             }
-            if (((pm_hash_pattern_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_hash_pattern_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_hash_pattern_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_hash_pattern_node_t *)node)->closing_loc, buffer);
             }
             break;
         }
         case PM_IF_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            if (((pm_if_node_t *)node)->if_keyword_loc.start == NULL) {
+            if (((pm_if_node_t *)node)->if_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_if_node_t *)node)->if_keyword_loc, buffer);
+                pm_serialize_location(&((pm_if_node_t *)node)->if_keyword_loc, buffer);
             }
             pm_serialize_node(parser, (pm_node_t *)((pm_if_node_t *)node)->predicate, buffer);
-            if (((pm_if_node_t *)node)->then_keyword_loc.start == NULL) {
+            if (((pm_if_node_t *)node)->then_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_if_node_t *)node)->then_keyword_loc, buffer);
+                pm_serialize_location(&((pm_if_node_t *)node)->then_keyword_loc, buffer);
             }
             if (((pm_if_node_t *)node)->statements == NULL) {
                 pm_buffer_append_byte(buffer, 0);
@@ -1009,11 +1016,11 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_if_node_t *)node)->subsequent, buffer);
             }
-            if (((pm_if_node_t *)node)->end_keyword_loc.start == NULL) {
+            if (((pm_if_node_t *)node)->end_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_if_node_t *)node)->end_keyword_loc, buffer);
+                pm_serialize_location(&((pm_if_node_t *)node)->end_keyword_loc, buffer);
             }
             break;
         }
@@ -1039,12 +1046,12 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_in_node_t *)node)->statements, buffer);
             }
-            pm_serialize_location(parser, &((pm_in_node_t *)node)->in_loc, buffer);
-            if (((pm_in_node_t *)node)->then_loc.start == NULL) {
+            pm_serialize_location(&((pm_in_node_t *)node)->in_keyword_loc, buffer);
+            if (((pm_in_node_t *)node)->then_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_in_node_t *)node)->then_loc, buffer);
+                pm_serialize_location(&((pm_in_node_t *)node)->then_keyword_loc, buffer);
             }
             break;
         }
@@ -1055,25 +1062,25 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->receiver, buffer);
             }
-            if (((pm_index_and_write_node_t *)node)->call_operator_loc.start == NULL) {
+            if (((pm_index_and_write_node_t *)node)->call_operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_index_and_write_node_t *)node)->call_operator_loc, buffer);
+                pm_serialize_location(&((pm_index_and_write_node_t *)node)->call_operator_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_and_write_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_index_and_write_node_t *)node)->opening_loc, buffer);
             if (((pm_index_and_write_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->arguments, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_and_write_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_index_and_write_node_t *)node)->closing_loc, buffer);
             if (((pm_index_and_write_node_t *)node)->block == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->block, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_index_and_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->value, buffer);
             break;
         }
@@ -1084,26 +1091,26 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->receiver, buffer);
             }
-            if (((pm_index_operator_write_node_t *)node)->call_operator_loc.start == NULL) {
+            if (((pm_index_operator_write_node_t *)node)->call_operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->call_operator_loc, buffer);
+                pm_serialize_location(&((pm_index_operator_write_node_t *)node)->call_operator_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_index_operator_write_node_t *)node)->opening_loc, buffer);
             if (((pm_index_operator_write_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->arguments, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_index_operator_write_node_t *)node)->closing_loc, buffer);
             if (((pm_index_operator_write_node_t *)node)->block == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->block, buffer);
             }
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_index_operator_write_node_t *)node)->binary_operator));
-            pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->binary_operator_loc, buffer);
+            pm_serialize_location(&((pm_index_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->value, buffer);
             break;
         }
@@ -1114,38 +1121,38 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->receiver, buffer);
             }
-            if (((pm_index_or_write_node_t *)node)->call_operator_loc.start == NULL) {
+            if (((pm_index_or_write_node_t *)node)->call_operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_index_or_write_node_t *)node)->call_operator_loc, buffer);
+                pm_serialize_location(&((pm_index_or_write_node_t *)node)->call_operator_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_or_write_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_index_or_write_node_t *)node)->opening_loc, buffer);
             if (((pm_index_or_write_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->arguments, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_or_write_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_index_or_write_node_t *)node)->closing_loc, buffer);
             if (((pm_index_or_write_node_t *)node)->block == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->block, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_index_or_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->value, buffer);
             break;
         }
         case PM_INDEX_TARGET_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_index_target_node_t *)node)->receiver, buffer);
-            pm_serialize_location(parser, &((pm_index_target_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_index_target_node_t *)node)->opening_loc, buffer);
             if (((pm_index_target_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_target_node_t *)node)->arguments, buffer);
             }
-            pm_serialize_location(parser, &((pm_index_target_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_index_target_node_t *)node)->closing_loc, buffer);
             if (((pm_index_target_node_t *)node)->block == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
@@ -1156,16 +1163,16 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_and_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_instance_variable_and_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_instance_variable_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_instance_variable_and_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_instance_variable_and_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_and_write_node_t *)node)->value, buffer);
             break;
         }
         case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_operator_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_instance_variable_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_instance_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
+            pm_serialize_location(&((pm_instance_variable_operator_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_instance_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_operator_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_operator_write_node_t *)node)->binary_operator));
             break;
@@ -1173,8 +1180,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_or_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_instance_variable_or_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_instance_variable_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_instance_variable_or_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_instance_variable_or_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_or_write_node_t *)node)->value, buffer);
             break;
         }
@@ -1191,9 +1198,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_INSTANCE_VARIABLE_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_write_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_instance_variable_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_instance_variable_write_node_t *)node)->name_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_write_node_t *)node)->value, buffer);
-            pm_serialize_location(parser, &((pm_instance_variable_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_instance_variable_write_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_INTEGER_NODE: {
@@ -1203,77 +1210,77 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_interpolated_match_last_line_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_interpolated_match_last_line_node_t *)node)->opening_loc, buffer);
             uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_match_last_line_node_t *)node)->parts.size);
             pm_buffer_append_varuint(buffer, parts_size);
             for (uint32_t index = 0; index < parts_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_match_last_line_node_t *)node)->parts.nodes[index], buffer);
             }
-            pm_serialize_location(parser, &((pm_interpolated_match_last_line_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_interpolated_match_last_line_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_interpolated_regular_expression_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_interpolated_regular_expression_node_t *)node)->opening_loc, buffer);
             uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_regular_expression_node_t *)node)->parts.size);
             pm_buffer_append_varuint(buffer, parts_size);
             for (uint32_t index = 0; index < parts_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_regular_expression_node_t *)node)->parts.nodes[index], buffer);
             }
-            pm_serialize_location(parser, &((pm_interpolated_regular_expression_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_interpolated_regular_expression_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_INTERPOLATED_STRING_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            if (((pm_interpolated_string_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_interpolated_string_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_interpolated_string_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_interpolated_string_node_t *)node)->opening_loc, buffer);
             }
             uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_string_node_t *)node)->parts.size);
             pm_buffer_append_varuint(buffer, parts_size);
             for (uint32_t index = 0; index < parts_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_string_node_t *)node)->parts.nodes[index], buffer);
             }
-            if (((pm_interpolated_string_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_interpolated_string_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_interpolated_string_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_interpolated_string_node_t *)node)->closing_loc, buffer);
             }
             break;
         }
         case PM_INTERPOLATED_SYMBOL_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            if (((pm_interpolated_symbol_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_interpolated_symbol_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_interpolated_symbol_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_interpolated_symbol_node_t *)node)->opening_loc, buffer);
             }
             uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_symbol_node_t *)node)->parts.size);
             pm_buffer_append_varuint(buffer, parts_size);
             for (uint32_t index = 0; index < parts_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_symbol_node_t *)node)->parts.nodes[index], buffer);
             }
-            if (((pm_interpolated_symbol_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_interpolated_symbol_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_interpolated_symbol_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_interpolated_symbol_node_t *)node)->closing_loc, buffer);
             }
             break;
         }
         case PM_INTERPOLATED_X_STRING_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_interpolated_x_string_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_interpolated_x_string_node_t *)node)->opening_loc, buffer);
             uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_x_string_node_t *)node)->parts.size);
             pm_buffer_append_varuint(buffer, parts_size);
             for (uint32_t index = 0; index < parts_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_x_string_node_t *)node)->parts.nodes[index], buffer);
             }
-            pm_serialize_location(parser, &((pm_interpolated_x_string_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_interpolated_x_string_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_IT_LOCAL_VARIABLE_READ_NODE: {
@@ -1296,13 +1303,13 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_KEYWORD_REST_PARAMETER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_keyword_rest_parameter_node_t *)node)->name));
-            if (((pm_keyword_rest_parameter_node_t *)node)->name_loc.start == NULL) {
+            if (((pm_keyword_rest_parameter_node_t *)node)->name_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_keyword_rest_parameter_node_t *)node)->name_loc, buffer);
+                pm_serialize_location(&((pm_keyword_rest_parameter_node_t *)node)->name_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_keyword_rest_parameter_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_keyword_rest_parameter_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_LAMBDA_NODE: {
@@ -1312,9 +1319,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < locals_size; index++) {
                 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_lambda_node_t *)node)->locals.ids[index]));
             }
-            pm_serialize_location(parser, &((pm_lambda_node_t *)node)->operator_loc, buffer);
-            pm_serialize_location(parser, &((pm_lambda_node_t *)node)->opening_loc, buffer);
-            pm_serialize_location(parser, &((pm_lambda_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_lambda_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_lambda_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_lambda_node_t *)node)->closing_loc, buffer);
             if (((pm_lambda_node_t *)node)->parameters == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
@@ -1329,8 +1336,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_local_variable_and_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_local_variable_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_local_variable_and_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_local_variable_and_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_and_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_and_write_node_t *)node)->name));
             pm_buffer_append_varuint(buffer, ((pm_local_variable_and_write_node_t *)node)->depth);
@@ -1338,8 +1345,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_local_variable_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_local_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
+            pm_serialize_location(&((pm_local_variable_operator_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_local_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_operator_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_operator_write_node_t *)node)->name));
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_operator_write_node_t *)node)->binary_operator));
@@ -1348,8 +1355,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_local_variable_or_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_local_variable_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_local_variable_or_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_local_variable_or_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_or_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_or_write_node_t *)node)->name));
             pm_buffer_append_varuint(buffer, ((pm_local_variable_or_write_node_t *)node)->depth);
@@ -1371,31 +1378,31 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_write_node_t *)node)->name));
             pm_buffer_append_varuint(buffer, ((pm_local_variable_write_node_t *)node)->depth);
-            pm_serialize_location(parser, &((pm_local_variable_write_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_local_variable_write_node_t *)node)->name_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_write_node_t *)node)->value, buffer);
-            pm_serialize_location(parser, &((pm_local_variable_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_local_variable_write_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_MATCH_LAST_LINE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_match_last_line_node_t *)node)->opening_loc, buffer);
-            pm_serialize_location(parser, &((pm_match_last_line_node_t *)node)->content_loc, buffer);
-            pm_serialize_location(parser, &((pm_match_last_line_node_t *)node)->closing_loc, buffer);
-            pm_serialize_string(parser, &((pm_match_last_line_node_t *)node)->unescaped, buffer);
+            pm_serialize_location(&((pm_match_last_line_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_match_last_line_node_t *)node)->content_loc, buffer);
+            pm_serialize_location(&((pm_match_last_line_node_t *)node)->closing_loc, buffer);
+            pm_serialize_string(&((pm_match_last_line_node_t *)node)->unescaped, buffer);
             break;
         }
         case PM_MATCH_PREDICATE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_match_predicate_node_t *)node)->value, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_match_predicate_node_t *)node)->pattern, buffer);
-            pm_serialize_location(parser, &((pm_match_predicate_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_match_predicate_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case PM_MATCH_REQUIRED_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_match_required_node_t *)node)->value, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_match_required_node_t *)node)->pattern, buffer);
-            pm_serialize_location(parser, &((pm_match_required_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_match_required_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_MATCH_WRITE_NODE: {
@@ -1408,10 +1415,6 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             }
             break;
         }
-        case PM_MISSING_NODE: {
-            pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            break;
-        }
         case PM_MODULE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             uint32_t locals_size = pm_sizet_to_u32(((pm_module_node_t *)node)->locals.size);
@@ -1419,14 +1422,14 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < locals_size; index++) {
                 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_module_node_t *)node)->locals.ids[index]));
             }
-            pm_serialize_location(parser, &((pm_module_node_t *)node)->module_keyword_loc, buffer);
+            pm_serialize_location(&((pm_module_node_t *)node)->module_keyword_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_module_node_t *)node)->constant_path, buffer);
             if (((pm_module_node_t *)node)->body == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_module_node_t *)node)->body, buffer);
             }
-            pm_serialize_location(parser, &((pm_module_node_t *)node)->end_keyword_loc, buffer);
+            pm_serialize_location(&((pm_module_node_t *)node)->end_keyword_loc, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_module_node_t *)node)->name));
             break;
         }
@@ -1447,17 +1450,17 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < rights_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_multi_target_node_t *)node)->rights.nodes[index], buffer);
             }
-            if (((pm_multi_target_node_t *)node)->lparen_loc.start == NULL) {
+            if (((pm_multi_target_node_t *)node)->lparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_multi_target_node_t *)node)->lparen_loc, buffer);
+                pm_serialize_location(&((pm_multi_target_node_t *)node)->lparen_loc, buffer);
             }
-            if (((pm_multi_target_node_t *)node)->rparen_loc.start == NULL) {
+            if (((pm_multi_target_node_t *)node)->rparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_multi_target_node_t *)node)->rparen_loc, buffer);
+                pm_serialize_location(&((pm_multi_target_node_t *)node)->rparen_loc, buffer);
             }
             break;
         }
@@ -1478,19 +1481,19 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < rights_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_multi_write_node_t *)node)->rights.nodes[index], buffer);
             }
-            if (((pm_multi_write_node_t *)node)->lparen_loc.start == NULL) {
+            if (((pm_multi_write_node_t *)node)->lparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_multi_write_node_t *)node)->lparen_loc, buffer);
+                pm_serialize_location(&((pm_multi_write_node_t *)node)->lparen_loc, buffer);
             }
-            if (((pm_multi_write_node_t *)node)->rparen_loc.start == NULL) {
+            if (((pm_multi_write_node_t *)node)->rparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_multi_write_node_t *)node)->rparen_loc, buffer);
+                pm_serialize_location(&((pm_multi_write_node_t *)node)->rparen_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_multi_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_multi_write_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_multi_write_node_t *)node)->value, buffer);
             break;
         }
@@ -1501,17 +1504,23 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_next_node_t *)node)->arguments, buffer);
             }
-            pm_serialize_location(parser, &((pm_next_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_next_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case PM_NIL_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             break;
         }
+        case PM_NO_BLOCK_PARAMETER_NODE: {
+            pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
+            pm_serialize_location(&((pm_no_block_parameter_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_no_block_parameter_node_t *)node)->keyword_loc, buffer);
+            break;
+        }
         case PM_NO_KEYWORDS_PARAMETER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_no_keywords_parameter_node_t *)node)->operator_loc, buffer);
-            pm_serialize_location(parser, &((pm_no_keywords_parameter_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_no_keywords_parameter_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_no_keywords_parameter_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case PM_NUMBERED_PARAMETERS_NODE: {
@@ -1527,15 +1536,15 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_optional_keyword_parameter_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_optional_keyword_parameter_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_optional_keyword_parameter_node_t *)node)->name_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_optional_keyword_parameter_node_t *)node)->value, buffer);
             break;
         }
         case PM_OPTIONAL_PARAMETER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_optional_parameter_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_optional_parameter_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_optional_parameter_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_optional_parameter_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_optional_parameter_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_optional_parameter_node_t *)node)->value, buffer);
             break;
         }
@@ -1543,7 +1552,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_or_node_t *)node)->left, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_or_node_t *)node)->right, buffer);
-            pm_serialize_location(parser, &((pm_or_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_or_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_PARAMETERS_NODE: {
@@ -1592,22 +1601,22 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_parentheses_node_t *)node)->body, buffer);
             }
-            pm_serialize_location(parser, &((pm_parentheses_node_t *)node)->opening_loc, buffer);
-            pm_serialize_location(parser, &((pm_parentheses_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_parentheses_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_parentheses_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_PINNED_EXPRESSION_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_pinned_expression_node_t *)node)->expression, buffer);
-            pm_serialize_location(parser, &((pm_pinned_expression_node_t *)node)->operator_loc, buffer);
-            pm_serialize_location(parser, &((pm_pinned_expression_node_t *)node)->lparen_loc, buffer);
-            pm_serialize_location(parser, &((pm_pinned_expression_node_t *)node)->rparen_loc, buffer);
+            pm_serialize_location(&((pm_pinned_expression_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_pinned_expression_node_t *)node)->lparen_loc, buffer);
+            pm_serialize_location(&((pm_pinned_expression_node_t *)node)->rparen_loc, buffer);
             break;
         }
         case PM_PINNED_VARIABLE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_pinned_variable_node_t *)node)->variable, buffer);
-            pm_serialize_location(parser, &((pm_pinned_variable_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_pinned_variable_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_POST_EXECUTION_NODE: {
@@ -1617,9 +1626,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_post_execution_node_t *)node)->statements, buffer);
             }
-            pm_serialize_location(parser, &((pm_post_execution_node_t *)node)->keyword_loc, buffer);
-            pm_serialize_location(parser, &((pm_post_execution_node_t *)node)->opening_loc, buffer);
-            pm_serialize_location(parser, &((pm_post_execution_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_post_execution_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_post_execution_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_post_execution_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_PRE_EXECUTION_NODE: {
@@ -1629,9 +1638,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_pre_execution_node_t *)node)->statements, buffer);
             }
-            pm_serialize_location(parser, &((pm_pre_execution_node_t *)node)->keyword_loc, buffer);
-            pm_serialize_location(parser, &((pm_pre_execution_node_t *)node)->opening_loc, buffer);
-            pm_serialize_location(parser, &((pm_pre_execution_node_t *)node)->closing_loc, buffer);
+            pm_serialize_location(&((pm_pre_execution_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_pre_execution_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_pre_execution_node_t *)node)->closing_loc, buffer);
             break;
         }
         case PM_PROGRAM_NODE: {
@@ -1656,7 +1665,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_range_node_t *)node)->right, buffer);
             }
-            pm_serialize_location(parser, &((pm_range_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_range_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_RATIONAL_NODE: {
@@ -1671,16 +1680,16 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_REGULAR_EXPRESSION_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_regular_expression_node_t *)node)->opening_loc, buffer);
-            pm_serialize_location(parser, &((pm_regular_expression_node_t *)node)->content_loc, buffer);
-            pm_serialize_location(parser, &((pm_regular_expression_node_t *)node)->closing_loc, buffer);
-            pm_serialize_string(parser, &((pm_regular_expression_node_t *)node)->unescaped, buffer);
+            pm_serialize_location(&((pm_regular_expression_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_regular_expression_node_t *)node)->content_loc, buffer);
+            pm_serialize_location(&((pm_regular_expression_node_t *)node)->closing_loc, buffer);
+            pm_serialize_string(&((pm_regular_expression_node_t *)node)->unescaped, buffer);
             break;
         }
         case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_required_keyword_parameter_node_t *)node)->name));
-            pm_serialize_location(parser, &((pm_required_keyword_parameter_node_t *)node)->name_loc, buffer);
+            pm_serialize_location(&((pm_required_keyword_parameter_node_t *)node)->name_loc, buffer);
             break;
         }
         case PM_REQUIRED_PARAMETER_NODE: {
@@ -1691,34 +1700,34 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_RESCUE_MODIFIER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_serialize_node(parser, (pm_node_t *)((pm_rescue_modifier_node_t *)node)->expression, buffer);
-            pm_serialize_location(parser, &((pm_rescue_modifier_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_rescue_modifier_node_t *)node)->keyword_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_rescue_modifier_node_t *)node)->rescue_expression, buffer);
             break;
         }
         case PM_RESCUE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_rescue_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_rescue_node_t *)node)->keyword_loc, buffer);
             uint32_t exceptions_size = pm_sizet_to_u32(((pm_rescue_node_t *)node)->exceptions.size);
             pm_buffer_append_varuint(buffer, exceptions_size);
             for (uint32_t index = 0; index < exceptions_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_rescue_node_t *)node)->exceptions.nodes[index], buffer);
             }
-            if (((pm_rescue_node_t *)node)->operator_loc.start == NULL) {
+            if (((pm_rescue_node_t *)node)->operator_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_rescue_node_t *)node)->operator_loc, buffer);
+                pm_serialize_location(&((pm_rescue_node_t *)node)->operator_loc, buffer);
             }
             if (((pm_rescue_node_t *)node)->reference == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_rescue_node_t *)node)->reference, buffer);
             }
-            if (((pm_rescue_node_t *)node)->then_keyword_loc.start == NULL) {
+            if (((pm_rescue_node_t *)node)->then_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_rescue_node_t *)node)->then_keyword_loc, buffer);
+                pm_serialize_location(&((pm_rescue_node_t *)node)->then_keyword_loc, buffer);
             }
             if (((pm_rescue_node_t *)node)->statements == NULL) {
                 pm_buffer_append_byte(buffer, 0);
@@ -1735,13 +1744,13 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_REST_PARAMETER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_rest_parameter_node_t *)node)->name));
-            if (((pm_rest_parameter_node_t *)node)->name_loc.start == NULL) {
+            if (((pm_rest_parameter_node_t *)node)->name_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_rest_parameter_node_t *)node)->name_loc, buffer);
+                pm_serialize_location(&((pm_rest_parameter_node_t *)node)->name_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_rest_parameter_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_rest_parameter_node_t *)node)->operator_loc, buffer);
             break;
         }
         case PM_RETRY_NODE: {
@@ -1750,7 +1759,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_RETURN_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_return_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_return_node_t *)node)->keyword_loc, buffer);
             if (((pm_return_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
@@ -1774,15 +1783,15 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < locals_size; index++) {
                 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_singleton_class_node_t *)node)->locals.ids[index]));
             }
-            pm_serialize_location(parser, &((pm_singleton_class_node_t *)node)->class_keyword_loc, buffer);
-            pm_serialize_location(parser, &((pm_singleton_class_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_singleton_class_node_t *)node)->class_keyword_loc, buffer);
+            pm_serialize_location(&((pm_singleton_class_node_t *)node)->operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_singleton_class_node_t *)node)->expression, buffer);
             if (((pm_singleton_class_node_t *)node)->body == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_singleton_class_node_t *)node)->body, buffer);
             }
-            pm_serialize_location(parser, &((pm_singleton_class_node_t *)node)->end_keyword_loc, buffer);
+            pm_serialize_location(&((pm_singleton_class_node_t *)node)->end_keyword_loc, buffer);
             break;
         }
         case PM_SOURCE_ENCODING_NODE: {
@@ -1791,7 +1800,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_SOURCE_FILE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_string(parser, &((pm_source_file_node_t *)node)->filepath, buffer);
+            pm_serialize_string(&((pm_source_file_node_t *)node)->filepath, buffer);
             break;
         }
         case PM_SOURCE_LINE_NODE: {
@@ -1800,7 +1809,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_SPLAT_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_splat_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(&((pm_splat_node_t *)node)->operator_loc, buffer);
             if (((pm_splat_node_t *)node)->expression == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
@@ -1819,41 +1828,41 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_STRING_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            if (((pm_string_node_t *)node)->opening_loc.start == NULL) {
+            if (((pm_string_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_string_node_t *)node)->opening_loc, buffer);
+                pm_serialize_location(&((pm_string_node_t *)node)->opening_loc, buffer);
             }
-            pm_serialize_location(parser, &((pm_string_node_t *)node)->content_loc, buffer);
-            if (((pm_string_node_t *)node)->closing_loc.start == NULL) {
+            pm_serialize_location(&((pm_string_node_t *)node)->content_loc, buffer);
+            if (((pm_string_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_string_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_string_node_t *)node)->closing_loc, buffer);
             }
-            pm_serialize_string(parser, &((pm_string_node_t *)node)->unescaped, buffer);
+            pm_serialize_string(&((pm_string_node_t *)node)->unescaped, buffer);
             break;
         }
         case PM_SUPER_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_super_node_t *)node)->keyword_loc, buffer);
-            if (((pm_super_node_t *)node)->lparen_loc.start == NULL) {
+            pm_serialize_location(&((pm_super_node_t *)node)->keyword_loc, buffer);
+            if (((pm_super_node_t *)node)->lparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_super_node_t *)node)->lparen_loc, buffer);
+                pm_serialize_location(&((pm_super_node_t *)node)->lparen_loc, buffer);
             }
             if (((pm_super_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_super_node_t *)node)->arguments, buffer);
             }
-            if (((pm_super_node_t *)node)->rparen_loc.start == NULL) {
+            if (((pm_super_node_t *)node)->rparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_super_node_t *)node)->rparen_loc, buffer);
+                pm_serialize_location(&((pm_super_node_t *)node)->rparen_loc, buffer);
             }
             if (((pm_super_node_t *)node)->block == NULL) {
                 pm_buffer_append_byte(buffer, 0);
@@ -1864,25 +1873,20 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_SYMBOL_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            if (((pm_symbol_node_t *)node)->opening_loc.start == NULL) {
-                pm_buffer_append_byte(buffer, 0);
-            } else {
-                pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_symbol_node_t *)node)->opening_loc, buffer);
-            }
-            if (((pm_symbol_node_t *)node)->value_loc.start == NULL) {
+            if (((pm_symbol_node_t *)node)->opening_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_symbol_node_t *)node)->value_loc, buffer);
+                pm_serialize_location(&((pm_symbol_node_t *)node)->opening_loc, buffer);
             }
-            if (((pm_symbol_node_t *)node)->closing_loc.start == NULL) {
+            pm_serialize_location(&((pm_symbol_node_t *)node)->content_loc, buffer);
+            if (((pm_symbol_node_t *)node)->closing_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_symbol_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_symbol_node_t *)node)->closing_loc, buffer);
             }
-            pm_serialize_string(parser, &((pm_symbol_node_t *)node)->unescaped, buffer);
+            pm_serialize_string(&((pm_symbol_node_t *)node)->unescaped, buffer);
             break;
         }
         case PM_TRUE_NODE: {
@@ -1896,18 +1900,18 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             for (uint32_t index = 0; index < names_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_undef_node_t *)node)->names.nodes[index], buffer);
             }
-            pm_serialize_location(parser, &((pm_undef_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_undef_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case PM_UNLESS_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_unless_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_unless_node_t *)node)->unless_keyword_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_unless_node_t *)node)->predicate, buffer);
-            if (((pm_unless_node_t *)node)->then_keyword_loc.start == NULL) {
+            if (((pm_unless_node_t *)node)->then_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_unless_node_t *)node)->then_keyword_loc, buffer);
+                pm_serialize_location(&((pm_unless_node_t *)node)->then_keyword_loc, buffer);
             }
             if (((pm_unless_node_t *)node)->statements == NULL) {
                 pm_buffer_append_byte(buffer, 0);
@@ -1919,28 +1923,28 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_unless_node_t *)node)->else_clause, buffer);
             }
-            if (((pm_unless_node_t *)node)->end_keyword_loc.start == NULL) {
+            if (((pm_unless_node_t *)node)->end_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_unless_node_t *)node)->end_keyword_loc, buffer);
+                pm_serialize_location(&((pm_unless_node_t *)node)->end_keyword_loc, buffer);
             }
             break;
         }
         case PM_UNTIL_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_until_node_t *)node)->keyword_loc, buffer);
-            if (((pm_until_node_t *)node)->do_keyword_loc.start == NULL) {
+            pm_serialize_location(&((pm_until_node_t *)node)->until_keyword_loc, buffer);
+            if (((pm_until_node_t *)node)->do_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_until_node_t *)node)->do_keyword_loc, buffer);
+                pm_serialize_location(&((pm_until_node_t *)node)->do_keyword_loc, buffer);
             }
-            if (((pm_until_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_until_node_t *)node)->end_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_until_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_until_node_t *)node)->end_keyword_loc, buffer);
             }
             pm_serialize_node(parser, (pm_node_t *)((pm_until_node_t *)node)->predicate, buffer);
             if (((pm_until_node_t *)node)->statements == NULL) {
@@ -1952,17 +1956,17 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_WHEN_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_when_node_t *)node)->keyword_loc, buffer);
+            pm_serialize_location(&((pm_when_node_t *)node)->when_keyword_loc, buffer);
             uint32_t conditions_size = pm_sizet_to_u32(((pm_when_node_t *)node)->conditions.size);
             pm_buffer_append_varuint(buffer, conditions_size);
             for (uint32_t index = 0; index < conditions_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_when_node_t *)node)->conditions.nodes[index], buffer);
             }
-            if (((pm_when_node_t *)node)->then_keyword_loc.start == NULL) {
+            if (((pm_when_node_t *)node)->then_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_when_node_t *)node)->then_keyword_loc, buffer);
+                pm_serialize_location(&((pm_when_node_t *)node)->then_keyword_loc, buffer);
             }
             if (((pm_when_node_t *)node)->statements == NULL) {
                 pm_buffer_append_byte(buffer, 0);
@@ -1973,18 +1977,18 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_WHILE_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_while_node_t *)node)->keyword_loc, buffer);
-            if (((pm_while_node_t *)node)->do_keyword_loc.start == NULL) {
+            pm_serialize_location(&((pm_while_node_t *)node)->while_keyword_loc, buffer);
+            if (((pm_while_node_t *)node)->do_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_while_node_t *)node)->do_keyword_loc, buffer);
+                pm_serialize_location(&((pm_while_node_t *)node)->do_keyword_loc, buffer);
             }
-            if (((pm_while_node_t *)node)->closing_loc.start == NULL) {
+            if (((pm_while_node_t *)node)->end_keyword_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_while_node_t *)node)->closing_loc, buffer);
+                pm_serialize_location(&((pm_while_node_t *)node)->end_keyword_loc, buffer);
             }
             pm_serialize_node(parser, (pm_node_t *)((pm_while_node_t *)node)->predicate, buffer);
             if (((pm_while_node_t *)node)->statements == NULL) {
@@ -1996,39 +2000,42 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_X_STRING_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_x_string_node_t *)node)->opening_loc, buffer);
-            pm_serialize_location(parser, &((pm_x_string_node_t *)node)->content_loc, buffer);
-            pm_serialize_location(parser, &((pm_x_string_node_t *)node)->closing_loc, buffer);
-            pm_serialize_string(parser, &((pm_x_string_node_t *)node)->unescaped, buffer);
+            pm_serialize_location(&((pm_x_string_node_t *)node)->opening_loc, buffer);
+            pm_serialize_location(&((pm_x_string_node_t *)node)->content_loc, buffer);
+            pm_serialize_location(&((pm_x_string_node_t *)node)->closing_loc, buffer);
+            pm_serialize_string(&((pm_x_string_node_t *)node)->unescaped, buffer);
             break;
         }
         case PM_YIELD_NODE: {
             pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
-            pm_serialize_location(parser, &((pm_yield_node_t *)node)->keyword_loc, buffer);
-            if (((pm_yield_node_t *)node)->lparen_loc.start == NULL) {
+            pm_serialize_location(&((pm_yield_node_t *)node)->keyword_loc, buffer);
+            if (((pm_yield_node_t *)node)->lparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_yield_node_t *)node)->lparen_loc, buffer);
+                pm_serialize_location(&((pm_yield_node_t *)node)->lparen_loc, buffer);
             }
             if (((pm_yield_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_yield_node_t *)node)->arguments, buffer);
             }
-            if (((pm_yield_node_t *)node)->rparen_loc.start == NULL) {
+            if (((pm_yield_node_t *)node)->rparen_loc.length == 0) {
                 pm_buffer_append_byte(buffer, 0);
             } else {
                 pm_buffer_append_byte(buffer, 1);
-                pm_serialize_location(parser, &((pm_yield_node_t *)node)->rparen_loc, buffer);
+                pm_serialize_location(&((pm_yield_node_t *)node)->rparen_loc, buffer);
             }
             break;
         }
     }
 }
 
-static void
-pm_serialize_newline_list(pm_newline_list_t *list, pm_buffer_t *buffer) {
+/*
+ * 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);
 
@@ -2039,60 +2046,88 @@ pm_serialize_newline_list(pm_newline_list_t *list, pm_buffer_t *buffer) {
 }
 
 static void
-pm_serialize_comment(pm_parser_t *parser, pm_comment_t *comment, pm_buffer_t *buffer) {
+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(parser, &comment->location, buffer);
+    pm_serialize_location(&comment->location, buffer);
 }
 
 /**
  * Serialize the given list of comments to the given buffer.
  */
 void
-pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
+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(parser, comment, buffer);
+        pm_serialize_comment(comment, buffer);
     }
 }
 
+/**
+ * Serialize the comments attached to each node. This is the number of nodes
+ * that own comments, followed by each of those nodes' id, the number of
+ * comments it owns, and the index of each of those comments in the comment
+ * list.
+ */
 static void
-pm_serialize_magic_comment(pm_parser_t *parser, pm_magic_comment_t *magic_comment, pm_buffer_t *buffer) {
+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, pm_ptrdifft_to_u32(magic_comment->key_start - parser->start));
-    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(magic_comment->key_length));
+    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, pm_ptrdifft_to_u32(magic_comment->value_start - parser->start));
-    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(magic_comment->value_length));
+    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_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
+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(parser, magic_comment, buffer);
+        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.end == NULL) {
+    if (parser->data_loc.length == 0) {
         pm_buffer_append_byte(buffer, 0);
     } else {
         pm_buffer_append_byte(buffer, 1);
-        pm_serialize_location(parser, &parser->data_loc, buffer);
+        pm_serialize_location(&parser->data_loc, buffer);
     }
 }
 
 static void
-pm_serialize_diagnostic(pm_parser_t *parser, pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) {
+pm_serialize_diagnostic(pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) {
     // serialize the type
     pm_buffer_append_varuint(buffer, (uint32_t) diagnostic->diag_id);
 
@@ -2102,18 +2137,18 @@ pm_serialize_diagnostic(pm_parser_t *parser, pm_diagnostic_t *diagnostic, pm_buf
     pm_buffer_append_string(buffer, diagnostic->message, message_length);
 
     // serialize location
-    pm_serialize_location(parser, &diagnostic->location, buffer);
+    pm_serialize_location(&diagnostic->location, buffer);
 
     pm_buffer_append_byte(buffer, diagnostic->level);
 }
 
 static void
-pm_serialize_diagnostic_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
+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(parser, diagnostic, buffer);
+        pm_serialize_diagnostic(diagnostic, buffer);
     }
 }
 
@@ -2131,15 +2166,18 @@ 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_serialize_newline_list(&parser->newline_list, buffer);
-    pm_serialize_comment_list(parser, &parser->comment_list, buffer);
-    pm_serialize_magic_comment_list(parser, &parser->magic_comment_list, buffer);
+    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, &parser->error_list, buffer);
-    pm_serialize_diagnostic_list(parser, &parser->warning_list, 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 275 "prism/templates/src/serialize.c.erb"
+#line 310 "prism/templates/src/serialize.c.erb"
 /**
  * Serialize the metadata, nodes, and constant pool.
  */
@@ -2176,28 +2214,12 @@ pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer)
             pm_constant_t *constant = &parser->constant_pool.constants[bucket->id - 1];
             size_t buffer_offset = offset + ((((size_t)bucket->id) - 1) * 8);
 
-            if (bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED || bucket->type == PM_CONSTANT_POOL_BUCKET_CONSTANT) {
-                // Since this is an owned or constant constant, we are going to
-                // write its contents into the buffer after the constant pool.
-                // So effectively in place of the source offset, we have a
-                // buffer offset. We will add a leading 1 to indicate that this
-                // is a buffer offset.
-                uint32_t content_offset = pm_sizet_to_u32(buffer->length);
-                uint32_t owned_mask = 1U << 31;
-
-                assert(content_offset < owned_mask);
-                content_offset |= owned_mask;
-
-                memcpy(buffer->value + buffer_offset, &content_offset, 4);
-                pm_buffer_append_bytes(buffer, constant->start, constant->length);
-            } else {
-                // Since this is a shared constant, we are going to write its
-                // source offset directly into the buffer.
-                uint32_t source_offset = pm_ptrdifft_to_u32(constant->start - parser->start);
-                memcpy(buffer->value + buffer_offset, &source_offset, 4);
-            }
+            // 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);
 
-            // Now we can write the length of the constant into the buffer.
             uint32_t constant_length = pm_sizet_to_u32(constant->length);
             memcpy(buffer->value + buffer_offset + 4, &constant_length, 4);
         }
@@ -2205,7 +2227,7 @@ pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer)
 }
 
 static void
-serialize_token(void *data, pm_parser_t *parser, pm_token_t *token) {
+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);
@@ -2217,58 +2239,72 @@ serialize_token(void *data, pm_parser_t *parser, pm_token_t *token) {
 /**
  * Lex the given source and serialize to the given buffer.
  */
-PRISM_EXPORTED_FUNCTION void
+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(&parser, source, size, &options);
+    pm_parser_init(&arena, &parser, source, size, &options);
 
-    pm_lex_callback_t lex_callback = (pm_lex_callback_t) {
-        .data = (void *) buffer,
-        .callback = serialize_token,
-    };
-
-    parser.lex_callback = &lex_callback;
-    pm_node_t *node = pm_parse(&parser);
+    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_node_destroy(&parser, node);
-    pm_parser_free(&parser);
-    pm_options_free(&options);
+    pm_parser_cleanup(&parser);
+    pm_arena_cleanup(&arena);
+    pm_options_cleanup(&options);
 }
 
 /**
  * Parse and serialize both the AST and the tokens represented by the given
  * source to the given buffer.
  */
-PRISM_EXPORTED_FUNCTION void
+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(&parser, source, size, &options);
+    pm_parser_init(&arena, &parser, source, size, &options);
 
-    pm_lex_callback_t lex_callback = (pm_lex_callback_t) {
-        .data = (void *) buffer,
-        .callback = serialize_token,
-    };
-
-    parser.lex_callback = &lex_callback;
+    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_node_destroy(&parser, node);
-    pm_parser_free(&parser);
-    pm_options_free(&options);
+    pm_parser_cleanup(&parser);
+    pm_arena_cleanup(&arena);
+    pm_options_cleanup(&options);
+}
+
+/**
+ * Parse the source and return true if it parses without errors or warnings.
+ */
+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