yarp 0.7.0 → 0.9.0

data/src/yarp.c

@@ -1,5 +1,4 @@
 #include "yarp.h"
-#include "yarp/version.h"
 
 // The YARP version and the serialization format.
 const char *
@@ -362,7 +361,7 @@ lex_state_ignored_p(yp_parser_t *parser) {
 
     if (ignored) {
         return YP_IGNORED_NEWLINE_ALL;
-    } else if (parser->lex_state == (YP_LEX_STATE_ARG | YP_LEX_STATE_LABELED)) {
+    } else if ((parser->lex_state & ~((unsigned int) YP_LEX_STATE_LABEL)) == (YP_LEX_STATE_ARG | YP_LEX_STATE_LABELED)) {
         return YP_IGNORED_NEWLINE_PATTERN;
     } else {
         return YP_IGNORED_NEWLINE_NONE;
@@ -450,8 +449,8 @@ yp_flip_flop(yp_node_t *node) {
         case YP_NODE_PARENTHESES_NODE: {
             yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
 
-            if ((cast->statements != NULL) && YP_NODE_TYPE_P(cast->statements, YP_NODE_STATEMENTS_NODE)) {
-                yp_statements_node_t *statements = (yp_statements_node_t *) cast->statements;
+            if ((cast->body != NULL) && YP_NODE_TYPE_P(cast->body, YP_NODE_STATEMENTS_NODE)) {
+                yp_statements_node_t *statements = (yp_statements_node_t *) cast->body;
                 if (statements->body.size == 1) yp_flip_flop(statements->body.nodes[0]);
             }
 
@@ -459,8 +458,12 @@ yp_flip_flop(yp_node_t *node) {
         }
         case YP_NODE_RANGE_NODE: {
             yp_range_node_t *cast = (yp_range_node_t *) node;
-            yp_flip_flop(cast->left);
-            yp_flip_flop(cast->right);
+            if (cast->left) {
+                yp_flip_flop(cast->left);
+            }
+            if (cast->right) {
+                yp_flip_flop(cast->right);
+            }
 
             // Here we change the range node into a flip flop node. We can do
             // this since the nodes are exactly the same except for the type.
@@ -532,6 +535,73 @@ yp_arguments_validate(yp_parser_t *parser, yp_arguments_t *arguments) {
     }
 }
 
+/******************************************************************************/
+/* Scope node functions                                                       */
+/******************************************************************************/
+
+// Generate a scope node from the given node.
+void
+yp_scope_node_init(yp_node_t *node, yp_scope_node_t *scope) {
+    scope->base.type = YP_NODE_SCOPE_NODE;
+    scope->base.location.start = node->location.start;
+    scope->base.location.end = node->location.end;
+
+    scope->parameters = NULL;
+    scope->body = NULL;
+    yp_constant_id_list_init(&scope->locals);
+
+    switch (YP_NODE_TYPE(node)) {
+        case YP_NODE_BLOCK_NODE: {
+            yp_block_node_t *cast = (yp_block_node_t *) node;
+            if (cast->parameters) scope->parameters = cast->parameters->parameters;
+            scope->body = cast->body;
+            scope->locals = cast->locals;
+            break;
+        }
+        case YP_NODE_CLASS_NODE: {
+            yp_class_node_t *cast = (yp_class_node_t *) node;
+            scope->body = cast->body;
+            scope->locals = cast->locals;
+            break;
+        }
+        case YP_NODE_DEF_NODE: {
+            yp_def_node_t *cast = (yp_def_node_t *) node;
+            scope->parameters = cast->parameters;
+            scope->body = cast->body;
+            scope->locals = cast->locals;
+            break;
+        }
+        case YP_NODE_LAMBDA_NODE: {
+            yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
+            if (cast->parameters) scope->parameters = cast->parameters->parameters;
+            scope->body = cast->body;
+            scope->locals = cast->locals;
+            break;
+        }
+        case YP_NODE_MODULE_NODE: {
+            yp_module_node_t *cast = (yp_module_node_t *) node;
+            scope->body = cast->body;
+            scope->locals = cast->locals;
+            break;
+        }
+        case YP_NODE_PROGRAM_NODE: {
+            yp_program_node_t *cast = (yp_program_node_t *) node;
+            scope->body = (yp_node_t *) cast->statements;
+            scope->locals = cast->locals;
+            break;
+        }
+        case YP_NODE_SINGLETON_CLASS_NODE: {
+            yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
+            scope->body = cast->body;
+            scope->locals = cast->locals;
+            break;
+        }
+        default:
+            assert(false && "unreachable");
+            break;
+    }
+}
+
 /******************************************************************************/
 /* Node creation functions                                                    */
 /******************************************************************************/
@@ -993,7 +1063,7 @@ yp_block_argument_node_create(yp_parser_t *parser, const yp_token_t *operator, y
 
 // Allocate and initialize a new BlockNode node.
 static yp_block_node_t *
-yp_block_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const yp_token_t *opening, yp_block_parameters_node_t *parameters, yp_node_t *statements, const yp_token_t *closing) {
+yp_block_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const yp_token_t *opening, yp_block_parameters_node_t *parameters, yp_node_t *body, const yp_token_t *closing) {
     yp_block_node_t *node = YP_ALLOC_NODE(parser, yp_block_node_t);
 
     *node = (yp_block_node_t) {
@@ -1003,7 +1073,7 @@ yp_block_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const y
         },
         .locals = *locals,
         .parameters = parameters,
-        .statements = statements,
+        .body = body,
         .opening_loc = YP_LOCATION_TOKEN_VALUE(opening),
         .closing_loc = YP_LOCATION_TOKEN_VALUE(closing)
     };
@@ -1126,7 +1196,7 @@ yp_call_node_create(yp_parser_t *parser) {
         },
         .receiver = NULL,
         .operator_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
-        .message_loc = YP_LOCATION_NULL_VALUE(parser),
+        .message_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
         .opening_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
         .arguments = NULL,
         .closing_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
@@ -1461,7 +1531,7 @@ yp_case_node_end_keyword_loc_set(yp_case_node_t *node, const yp_token_t *end_key
 
 // Allocate a new ClassNode node.
 static yp_class_node_t *
-yp_class_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const yp_token_t *class_keyword, yp_node_t *constant_path, const yp_token_t *inheritance_operator, yp_node_t *superclass, yp_node_t *statements, const yp_token_t *end_keyword) {
+yp_class_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const yp_token_t *class_keyword, yp_node_t *constant_path, const yp_token_t *name, const yp_token_t *inheritance_operator, yp_node_t *superclass, yp_node_t *body, const yp_token_t *end_keyword) {
     yp_class_node_t *node = YP_ALLOC_NODE(parser, yp_class_node_t);
 
     *node = (yp_class_node_t) {
@@ -1474,23 +1544,25 @@ yp_class_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const y
         .constant_path = constant_path,
         .inheritance_operator_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(inheritance_operator),
         .superclass = superclass,
-        .statements = statements,
-        .end_keyword_loc = YP_LOCATION_TOKEN_VALUE(end_keyword)
+        .body = body,
+        .end_keyword_loc = YP_LOCATION_TOKEN_VALUE(end_keyword),
+        .name = YP_EMPTY_STRING
     };
 
+    yp_string_shared_init(&node->name, name->start, name->end);
     return node;
 }
 
-// Allocate and initialize a new ClassVariableOperatorAndWriteNode node.
-static yp_class_variable_operator_and_write_node_t *
-yp_class_variable_operator_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new ClassVariableAndWriteNode node.
+static yp_class_variable_and_write_node_t *
+yp_class_variable_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_CLASS_VARIABLE_READ_NODE));
     assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
-    yp_class_variable_operator_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_class_variable_operator_and_write_node_t);
+    yp_class_variable_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_class_variable_and_write_node_t);
 
-    *node = (yp_class_variable_operator_and_write_node_t) {
+    *node = (yp_class_variable_and_write_node_t) {
         {
-            .type = YP_NODE_CLASS_VARIABLE_OPERATOR_AND_WRITE_NODE,
+            .type = YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -1526,16 +1598,16 @@ yp_class_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *tar
     return node;
 }
 
-// Allocate and initialize a new ClassVariableOperatorOrWriteNode node.
-static yp_class_variable_operator_or_write_node_t *
-yp_class_variable_operator_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new ClassVariableOrWriteNode node.
+static yp_class_variable_or_write_node_t *
+yp_class_variable_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_CLASS_VARIABLE_READ_NODE));
     assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL);
-    yp_class_variable_operator_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_class_variable_operator_or_write_node_t);
+    yp_class_variable_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_class_variable_or_write_node_t);
 
-    *node = (yp_class_variable_operator_or_write_node_t) {
+    *node = (yp_class_variable_or_write_node_t) {
         {
-            .type = YP_NODE_CLASS_VARIABLE_OPERATOR_OR_WRITE_NODE,
+            .type = YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -1568,10 +1640,10 @@ yp_class_variable_read_node_to_class_variable_write_node(yp_parser_t *parser, yp
             .type = YP_NODE_CLASS_VARIABLE_WRITE_NODE,
             .location = {
                 .start = read_node->base.location.start,
-                .end = value != NULL ? value->location.end : read_node->base.location.end
+                .end = value->location.end
             },
         },
-        .name_loc = YP_LOCATION_NODE_VALUE((yp_node_t *)read_node),
+        .name_loc = YP_LOCATION_NODE_VALUE((yp_node_t *) read_node),
         .operator_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
         .value = value
     };
@@ -1579,15 +1651,15 @@ yp_class_variable_read_node_to_class_variable_write_node(yp_parser_t *parser, yp
     return node;
 }
 
-// Allocate and initialize a new ConstantPathOperatorAndWriteNode node.
-static yp_constant_path_operator_and_write_node_t *
-yp_constant_path_operator_and_write_node_create(yp_parser_t *parser, yp_constant_path_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new ConstantPathAndWriteNode node.
+static yp_constant_path_and_write_node_t *
+yp_constant_path_and_write_node_create(yp_parser_t *parser, yp_constant_path_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
-    yp_constant_path_operator_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_path_operator_and_write_node_t);
+    yp_constant_path_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_path_and_write_node_t);
 
-    *node = (yp_constant_path_operator_and_write_node_t) {
+    *node = (yp_constant_path_and_write_node_t) {
         {
-            .type = YP_NODE_CONSTANT_PATH_OPERATOR_AND_WRITE_NODE,
+            .type = YP_NODE_CONSTANT_PATH_AND_WRITE_NODE,
             .location = {
                 .start = target->base.location.start,
                 .end = value->location.end
@@ -1623,15 +1695,15 @@ yp_constant_path_operator_write_node_create(yp_parser_t *parser, yp_constant_pat
     return node;
 }
 
-// Allocate and initialize a new ConstantPathOperatorOrWriteNode node.
-static yp_constant_path_operator_or_write_node_t *
-yp_constant_path_operator_or_write_node_create(yp_parser_t *parser, yp_constant_path_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new ConstantPathOrWriteNode node.
+static yp_constant_path_or_write_node_t *
+yp_constant_path_or_write_node_create(yp_parser_t *parser, yp_constant_path_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL);
-    yp_constant_path_operator_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_path_operator_or_write_node_t);
+    yp_constant_path_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_path_or_write_node_t);
 
-    *node = (yp_constant_path_operator_or_write_node_t) {
+    *node = (yp_constant_path_or_write_node_t) {
         {
-            .type = YP_NODE_CONSTANT_PATH_OPERATOR_OR_WRITE_NODE,
+            .type = YP_NODE_CONSTANT_PATH_OR_WRITE_NODE,
             .location = {
                 .start = target->base.location.start,
                 .end = value->location.end
@@ -1676,7 +1748,7 @@ yp_constant_path_write_node_create(yp_parser_t *parser, yp_constant_path_node_t
             .type = YP_NODE_CONSTANT_PATH_WRITE_NODE,
             .location = {
                 .start = target->base.location.start,
-                .end = (value == NULL ? target->base.location.end : value->location.end)
+                .end = value->location.end
             },
         },
         .target = target,
@@ -1687,16 +1759,16 @@ yp_constant_path_write_node_create(yp_parser_t *parser, yp_constant_path_node_t
     return node;
 }
 
-// Allocate and initialize a new ConstantOperatorAndWriteNode node.
-static yp_constant_operator_and_write_node_t *
-yp_constant_operator_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new ConstantAndWriteNode node.
+static yp_constant_and_write_node_t *
+yp_constant_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_CONSTANT_READ_NODE));
     assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
-    yp_constant_operator_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_operator_and_write_node_t);
+    yp_constant_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_and_write_node_t);
 
-    *node = (yp_constant_operator_and_write_node_t) {
+    *node = (yp_constant_and_write_node_t) {
         {
-            .type = YP_NODE_CONSTANT_OPERATOR_AND_WRITE_NODE,
+            .type = YP_NODE_CONSTANT_AND_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -1732,16 +1804,16 @@ yp_constant_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, c
     return node;
 }
 
-// Allocate and initialize a new ConstantOperatorOrWriteNode node.
-static yp_constant_operator_or_write_node_t *
-yp_constant_operator_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new ConstantOrWriteNode node.
+static yp_constant_or_write_node_t *
+yp_constant_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_CONSTANT_READ_NODE));
     assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL);
-    yp_constant_operator_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_operator_or_write_node_t);
+    yp_constant_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_or_write_node_t);
 
-    *node = (yp_constant_operator_or_write_node_t) {
+    *node = (yp_constant_or_write_node_t) {
         {
-            .type = YP_NODE_CONSTANT_OPERATOR_OR_WRITE_NODE,
+            .type = YP_NODE_CONSTANT_OR_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -1775,7 +1847,7 @@ yp_constant_write_node_create(yp_parser_t *parser, yp_location_t *name_loc, cons
             .type = YP_NODE_CONSTANT_WRITE_NODE,
             .location = {
                 .start = name_loc->start,
-                .end = value != NULL ? value->location.end : name_loc->end
+                .end = value->location.end
             },
         },
         .name_loc = *name_loc,
@@ -1793,7 +1865,7 @@ yp_def_node_create(
     const yp_token_t *name,
     yp_node_t *receiver,
     yp_parameters_node_t *parameters,
-    yp_node_t *statements,
+    yp_node_t *body,
     yp_constant_id_list_t *locals,
     const yp_token_t *def_keyword,
     const yp_token_t *operator,
@@ -1806,7 +1878,7 @@ yp_def_node_create(
     const char *end;
 
     if (end_keyword->type == YP_TOKEN_NOT_PROVIDED) {
-        end = statements->location.end;
+        end = body->location.end;
     } else {
         end = end_keyword->end;
     }
@@ -1819,7 +1891,7 @@ yp_def_node_create(
         .name_loc = YP_LOCATION_TOKEN_VALUE(name),
         .receiver = receiver,
         .parameters = parameters,
-        .statements = statements,
+        .body = body,
         .locals = *locals,
         .def_keyword_loc = YP_LOCATION_TOKEN_VALUE(def_keyword),
         .operator_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
@@ -2189,16 +2261,16 @@ yp_hash_pattern_node_node_list_create(yp_parser_t *parser, yp_node_list_t *assoc
     return node;
 }
 
-// Allocate and initialize a new GlobalVariableOperatorAndWriteNode node.
-static yp_global_variable_operator_and_write_node_t *
-yp_global_variable_operator_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new GlobalVariableAndWriteNode node.
+static yp_global_variable_and_write_node_t *
+yp_global_variable_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_GLOBAL_VARIABLE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_BACK_REFERENCE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_NUMBERED_REFERENCE_READ_NODE));
     assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
-    yp_global_variable_operator_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_global_variable_operator_and_write_node_t);
+    yp_global_variable_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_global_variable_and_write_node_t);
 
-    *node = (yp_global_variable_operator_and_write_node_t) {
+    *node = (yp_global_variable_and_write_node_t) {
         {
-            .type = YP_NODE_GLOBAL_VARIABLE_OPERATOR_AND_WRITE_NODE,
+            .type = YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -2234,16 +2306,16 @@ yp_global_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *ta
     return node;
 }
 
-// Allocate and initialize a new GlobalVariableOperatorOrWriteNode node.
-static yp_global_variable_operator_or_write_node_t *
-yp_global_variable_operator_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new GlobalVariableOrWriteNode node.
+static yp_global_variable_or_write_node_t *
+yp_global_variable_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_GLOBAL_VARIABLE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_BACK_REFERENCE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_NUMBERED_REFERENCE_READ_NODE));
     assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL);
-    yp_global_variable_operator_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_global_variable_operator_or_write_node_t);
+    yp_global_variable_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_global_variable_or_write_node_t);
 
-    *node = (yp_global_variable_operator_or_write_node_t) {
+    *node = (yp_global_variable_or_write_node_t) {
         {
-            .type = YP_NODE_GLOBAL_VARIABLE_OPERATOR_OR_WRITE_NODE,
+            .type = YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -2282,7 +2354,7 @@ yp_global_variable_write_node_create(yp_parser_t *parser, const yp_location_t *n
             .type = YP_NODE_GLOBAL_VARIABLE_WRITE_NODE,
             .location = {
                 .start = name_loc->start,
-                .end = (value == NULL ? name_loc->end : value->location.end)
+                .end = value->location.end
             },
         },
         .name_loc = *name_loc,
@@ -2547,16 +2619,16 @@ yp_in_node_create(yp_parser_t *parser, yp_node_t *pattern, yp_statements_node_t
     return node;
 }
 
-// Allocate and initialize a new InstanceVariableOperatorAndWriteNode node.
-static yp_instance_variable_operator_and_write_node_t *
-yp_instance_variable_operator_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new InstanceVariableAndWriteNode node.
+static yp_instance_variable_and_write_node_t *
+yp_instance_variable_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_INSTANCE_VARIABLE_READ_NODE));
     assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
-    yp_instance_variable_operator_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_instance_variable_operator_and_write_node_t);
+    yp_instance_variable_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_instance_variable_and_write_node_t);
 
-    *node = (yp_instance_variable_operator_and_write_node_t) {
+    *node = (yp_instance_variable_and_write_node_t) {
         {
-            .type = YP_NODE_INSTANCE_VARIABLE_OPERATOR_AND_WRITE_NODE,
+            .type = YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -2592,16 +2664,16 @@ yp_instance_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *
     return node;
 }
 
-// Allocate and initialize a new InstanceVariableOperatorOrWriteNode node.
-static yp_instance_variable_operator_or_write_node_t *
-yp_instance_variable_operator_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
+// Allocate and initialize a new InstanceVariableOrWriteNode node.
+static yp_instance_variable_or_write_node_t *
+yp_instance_variable_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_INSTANCE_VARIABLE_READ_NODE));
     assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL);
-    yp_instance_variable_operator_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_instance_variable_operator_or_write_node_t);
+    yp_instance_variable_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_instance_variable_or_write_node_t);
 
-    *node = (yp_instance_variable_operator_or_write_node_t) {
+    *node = (yp_instance_variable_or_write_node_t) {
         {
-            .type = YP_NODE_INSTANCE_VARIABLE_OPERATOR_OR_WRITE_NODE,
+            .type = YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -2637,7 +2709,7 @@ yp_instance_variable_write_node_create(yp_parser_t *parser, yp_instance_variable
             .type = YP_NODE_INSTANCE_VARIABLE_WRITE_NODE,
             .location = {
                 .start = read_node->base.location.start,
-                .end = value == NULL ? read_node->base.location.end : value->location.end
+                .end = value->location.end
             }
         },
         .name_loc = YP_LOCATION_NODE_BASE_VALUE(read_node),
@@ -2706,6 +2778,10 @@ yp_interpolated_string_node_create(yp_parser_t *parser, const yp_token_t *openin
 // Append a part to an InterpolatedStringNode node.
 static inline void
 yp_interpolated_string_node_append(yp_interpolated_string_node_t *node, yp_node_t *part) {
+    if (node->parts.size == 0 && node->opening_loc.start == NULL) {
+        node->base.location.start = part->location.start;
+    }
+
     yp_node_list_append(&node->parts, part);
     node->base.location.end = part->location.end;
 }
@@ -2747,12 +2823,6 @@ yp_interpolated_symbol_node_append(yp_interpolated_symbol_node_t *node, yp_node_
     node->base.location.end = part->location.end;
 }
 
-static inline void
-yp_interpolated_symbol_node_closing_set(yp_interpolated_symbol_node_t *node, const yp_token_t *closing) {
-    node->closing_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(closing);
-    node->base.location.end = closing->end;
-}
-
 // Allocate a new InterpolatedXStringNode node.
 static yp_interpolated_x_string_node_t *
 yp_interpolated_xstring_node_create(yp_parser_t *parser, const yp_token_t *opening, const yp_token_t *closing) {
@@ -2860,10 +2930,11 @@ static yp_lambda_node_t *
 yp_lambda_node_create(
     yp_parser_t *parser,
     yp_constant_id_list_t *locals,
+    const yp_token_t *operator,
     const yp_token_t *opening,
+    const yp_token_t *closing,
     yp_block_parameters_node_t *parameters,
-    yp_node_t *statements,
-    const yp_token_t *closing
+    yp_node_t *body
 ) {
     yp_lambda_node_t *node = YP_ALLOC_NODE(parser, yp_lambda_node_t);
 
@@ -2871,29 +2942,31 @@ yp_lambda_node_create(
         {
             .type = YP_NODE_LAMBDA_NODE,
             .location = {
-                .start = opening->start,
+                .start = operator->start,
                 .end = closing->end
             },
         },
         .locals = *locals,
+        .operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
         .opening_loc = YP_LOCATION_TOKEN_VALUE(opening),
+        .closing_loc = YP_LOCATION_TOKEN_VALUE(closing),
         .parameters = parameters,
-        .statements = statements
+        .body = body
     };
 
     return node;
 }
 
-// Allocate and initialize a new LocalVariableOperatorAndWriteNode node.
-static yp_local_variable_operator_and_write_node_t *
-yp_local_variable_operator_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id) {
+// Allocate and initialize a new LocalVariableAndWriteNode node.
+static yp_local_variable_and_write_node_t *
+yp_local_variable_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id, uint32_t depth) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_LOCAL_VARIABLE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_CALL_NODE));
     assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
-    yp_local_variable_operator_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_operator_and_write_node_t);
+    yp_local_variable_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_and_write_node_t);
 
-    *node = (yp_local_variable_operator_and_write_node_t) {
+    *node = (yp_local_variable_and_write_node_t) {
         {
-            .type = YP_NODE_LOCAL_VARIABLE_OPERATOR_AND_WRITE_NODE,
+            .type = YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -2902,7 +2975,8 @@ yp_local_variable_operator_and_write_node_create(yp_parser_t *parser, yp_node_t
         .name_loc = target->location,
         .operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
         .value = value,
-        .constant_id = constant_id
+        .constant_id = constant_id,
+        .depth = depth
     };
 
     return node;
@@ -2910,7 +2984,7 @@ yp_local_variable_operator_and_write_node_create(yp_parser_t *parser, yp_node_t
 
 // Allocate and initialize a new LocalVariableOperatorWriteNode node.
 static yp_local_variable_operator_write_node_t *
-yp_local_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id) {
+yp_local_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id, uint32_t depth) {
     yp_local_variable_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_operator_write_node_t);
 
     *node = (yp_local_variable_operator_write_node_t) {
@@ -2925,22 +2999,23 @@ yp_local_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *tar
         .operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
         .value = value,
         .constant_id = constant_id,
-        .operator_id = yp_parser_constant_id_location(parser, operator->start, operator->end - 1)
+        .operator_id = yp_parser_constant_id_location(parser, operator->start, operator->end - 1),
+        .depth = depth
     };
 
     return node;
 }
 
-// Allocate and initialize a new LocalVariableOperatorOrWriteNode node.
-static yp_local_variable_operator_or_write_node_t *
-yp_local_variable_operator_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id) {
+// Allocate and initialize a new LocalVariableOrWriteNode node.
+static yp_local_variable_or_write_node_t *
+yp_local_variable_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id, uint32_t depth) {
     assert(YP_NODE_TYPE_P(target, YP_NODE_LOCAL_VARIABLE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_CALL_NODE));
     assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL);
-    yp_local_variable_operator_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_operator_or_write_node_t);
+    yp_local_variable_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_or_write_node_t);
 
-    *node = (yp_local_variable_operator_or_write_node_t) {
+    *node = (yp_local_variable_or_write_node_t) {
         {
-            .type = YP_NODE_LOCAL_VARIABLE_OPERATOR_OR_WRITE_NODE,
+            .type = YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE,
             .location = {
                 .start = target->location.start,
                 .end = value->location.end
@@ -2949,7 +3024,8 @@ yp_local_variable_operator_or_write_node_create(yp_parser_t *parser, yp_node_t *
         .name_loc = target->location,
         .operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
         .value = value,
-        .constant_id = constant_id
+        .constant_id = constant_id,
+        .depth = depth
     };
 
     return node;
@@ -2982,7 +3058,7 @@ yp_local_variable_write_node_create(yp_parser_t *parser, yp_constant_id_t consta
             .type = YP_NODE_LOCAL_VARIABLE_WRITE_NODE,
             .location = {
                 .start = name_loc->start,
-                .end = value == NULL ? name_loc->end : value->location.end
+                .end = value->location.end
             }
         },
         .constant_id = constant_id,
@@ -2995,21 +3071,18 @@ yp_local_variable_write_node_create(yp_parser_t *parser, yp_constant_id_t consta
     return node;
 }
 
-// Allocate and initialize a new LocalVariableWriteNode node without an operator or target.
-static yp_local_variable_write_node_t *
+// Allocate and initialize a new LocalVariableTargetNode node.
+static yp_local_variable_target_node_t *
 yp_local_variable_target_node_create(yp_parser_t *parser, const yp_token_t *name) {
-    yp_local_variable_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_write_node_t);
+    yp_local_variable_target_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_target_node_t);
 
-    *node = (yp_local_variable_write_node_t) {
+    *node = (yp_local_variable_target_node_t) {
         {
-            .type = YP_NODE_LOCAL_VARIABLE_WRITE_NODE,
+            .type = YP_NODE_LOCAL_VARIABLE_TARGET_NODE,
             .location = YP_LOCATION_TOKEN_VALUE(name)
         },
         .constant_id = yp_parser_constant_id_token(parser, name),
-        .depth = 0,
-        .value = NULL,
-        .name_loc = YP_LOCATION_TOKEN_VALUE(name),
-        .operator_loc = { .start = NULL, .end = NULL }
+        .depth = 0
     };
 
     return node;
@@ -3059,7 +3132,7 @@ yp_match_required_node_create(yp_parser_t *parser, yp_node_t *value, yp_node_t *
 
 // Allocate a new ModuleNode node.
 static yp_module_node_t *
-yp_module_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const yp_token_t *module_keyword, yp_node_t *constant_path, yp_node_t *statements, const yp_token_t *end_keyword) {
+yp_module_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const yp_token_t *module_keyword, yp_node_t *constant_path, const yp_token_t *name, yp_node_t *body, const yp_token_t *end_keyword) {
     yp_module_node_t *node = YP_ALLOC_NODE(parser, yp_module_node_t);
 
     *node = (yp_module_node_t) {
@@ -3073,10 +3146,12 @@ yp_module_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const
         .locals = (locals == NULL ? ((yp_constant_id_list_t) { .ids = NULL, .size = 0, .capacity = 0 }) : *locals),
         .module_keyword_loc = YP_LOCATION_TOKEN_VALUE(module_keyword),
         .constant_path = constant_path,
-        .statements = statements,
-        .end_keyword_loc = YP_LOCATION_TOKEN_VALUE(end_keyword)
+        .body = body,
+        .end_keyword_loc = YP_LOCATION_TOKEN_VALUE(end_keyword),
+        .name = YP_EMPTY_STRING
     };
 
+    yp_string_shared_init(&node->name, name->start, name->end);
     return node;
 }
 
@@ -3088,7 +3163,10 @@ yp_multi_write_node_create(yp_parser_t *parser, const yp_token_t *operator, yp_n
     *node = (yp_multi_write_node_t) {
         {
             .type = YP_NODE_MULTI_WRITE_NODE,
-            .location = { .start = NULL, .end = NULL },
+            .location = {
+                .start = lparen_loc->start,
+                .end = value == NULL ? rparen_loc->end : value->location.end
+            },
         },
         .operator_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
         .value = value,
@@ -3343,7 +3421,7 @@ yp_program_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, yp_st
 
 // Allocate and initialize new ParenthesesNode node.
 static yp_parentheses_node_t *
-yp_parentheses_node_create(yp_parser_t *parser, const yp_token_t *opening, yp_node_t *statements, const yp_token_t *closing) {
+yp_parentheses_node_create(yp_parser_t *parser, const yp_token_t *opening, yp_node_t *body, const yp_token_t *closing) {
     yp_parentheses_node_t *node = YP_ALLOC_NODE(parser, yp_parentheses_node_t);
 
     *node = (yp_parentheses_node_t) {
@@ -3354,7 +3432,7 @@ yp_parentheses_node_create(yp_parser_t *parser, const yp_token_t *opening, yp_no
                 .end = closing->end
             }
         },
-        .statements = statements,
+        .body = body,
         .opening_loc = YP_LOCATION_TOKEN_VALUE(opening),
         .closing_loc = YP_LOCATION_TOKEN_VALUE(closing)
     };
@@ -3700,7 +3778,7 @@ yp_self_node_create(yp_parser_t *parser, const yp_token_t *token) {
 
 // Allocate a new SingletonClassNode node.
 static yp_singleton_class_node_t *
-yp_singleton_class_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const yp_token_t *class_keyword, const yp_token_t *operator, yp_node_t *expression, yp_node_t *statements, const yp_token_t *end_keyword) {
+yp_singleton_class_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const yp_token_t *class_keyword, const yp_token_t *operator, yp_node_t *expression, yp_node_t *body, const yp_token_t *end_keyword) {
     yp_singleton_class_node_t *node = YP_ALLOC_NODE(parser, yp_singleton_class_node_t);
 
     *node = (yp_singleton_class_node_t) {
@@ -3715,7 +3793,7 @@ yp_singleton_class_node_create(yp_parser_t *parser, yp_constant_id_list_t *local
         .class_keyword_loc = YP_LOCATION_TOKEN_VALUE(class_keyword),
         .operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
         .expression = expression,
-        .statements = statements,
+        .body = body,
         .end_keyword_loc = YP_LOCATION_TOKEN_VALUE(end_keyword)
     };
 
@@ -3934,10 +4012,10 @@ yp_symbol_node_label_create(yp_parser_t *parser, const yp_token_t *token) {
             yp_token_t label = { .type = YP_TOKEN_LABEL, .start = token->start, .end = token->end - 1 };
             node = yp_symbol_node_create(parser, &opening, &label, &closing);
 
-            ptrdiff_t length = label.end - label.start;
-            assert(length >= 0);
+            assert((label.end - label.start) >= 0);
+            yp_string_shared_init(&node->unescaped, label.start, label.end);
 
-            yp_unescape_manipulate_string(parser, label.start, (size_t) length, &node->unescaped, YP_UNESCAPE_ALL, &parser->error_list);
+            yp_unescape_manipulate_string(parser, &node->unescaped, YP_UNESCAPE_ALL);
             break;
         }
         case YP_TOKEN_MISSING: {
@@ -3978,20 +4056,20 @@ yp_symbol_node_label_p(yp_node_t *node) {
 
 // Convert the given StringNode node to a SymbolNode node.
 static yp_symbol_node_t *
-yp_string_node_to_symbol_node(yp_parser_t *parser, yp_string_node_t *node) {
+yp_string_node_to_symbol_node(yp_parser_t *parser, yp_string_node_t *node, const yp_token_t *opening, const yp_token_t *closing) {
     yp_symbol_node_t *new_node = YP_ALLOC_NODE(parser, yp_symbol_node_t);
 
     *new_node = (yp_symbol_node_t) {
         {
             .type = YP_NODE_SYMBOL_NODE,
             .location = {
-                .start = node->base.location.start - 2,
-                .end = node->base.location.end + 1
+                .start = opening->start,
+                .end = closing->end
             }
         },
-        .opening_loc = node->opening_loc,
+        .opening_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
         .value_loc = node->content_loc,
-        .closing_loc = node->closing_loc,
+        .closing_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
         .unescaped = node->unescaped
     };
 
@@ -4130,34 +4208,43 @@ yp_unless_node_end_keyword_loc_set(yp_unless_node_t *node, const yp_token_t *end
 
 // Allocate a new UntilNode node.
 static yp_until_node_t *
-yp_until_node_create(yp_parser_t *parser, const yp_token_t *keyword, yp_node_t *predicate, yp_statements_node_t *statements, yp_node_flags_t flags) {
+yp_until_node_create(yp_parser_t *parser, const yp_token_t *keyword, const yp_token_t *closing, yp_node_t *predicate, yp_statements_node_t *statements, yp_node_flags_t flags) {
     yp_until_node_t *node = YP_ALLOC_NODE(parser, yp_until_node_t);
-    bool has_statements = (statements != NULL) && (statements->body.size != 0);
 
-    const char *start = NULL;
-    if (has_statements && (keyword->start > statements->base.location.start)) {
-        start = statements->base.location.start;
-    } else {
-        start = keyword->start;
-    }
+    *node = (yp_until_node_t) {
+        {
+            .type = YP_NODE_UNTIL_NODE,
+            .flags = flags,
+            .location = {
+                .start = keyword->start,
+                .end = closing->end,
+            },
+        },
+        .keyword_loc = YP_LOCATION_TOKEN_VALUE(keyword),
+        .closing_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
+        .predicate = predicate,
+        .statements = statements
+    };
 
-    const char *end = NULL;
-    if (has_statements && (predicate->location.end < statements->base.location.end)) {
-        end = statements->base.location.end;
-    } else {
-        end = predicate->location.end;
-    }
+    return node;
+}
+
+// Allocate a new UntilNode node.
+static yp_until_node_t *
+yp_until_node_modifier_create(yp_parser_t *parser, const yp_token_t *keyword, yp_node_t *predicate, yp_statements_node_t *statements, yp_node_flags_t flags) {
+    yp_until_node_t *node = YP_ALLOC_NODE(parser, yp_until_node_t);
 
     *node = (yp_until_node_t) {
         {
             .type = YP_NODE_UNTIL_NODE,
             .flags = flags,
             .location = {
-                .start = start,
-                .end = end,
+                .start = statements->base.location.start,
+                .end = predicate->location.end,
             },
         },
         .keyword_loc = YP_LOCATION_TOKEN_VALUE(keyword),
+        .closing_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
         .predicate = predicate,
         .statements = statements
     };
@@ -4205,34 +4292,43 @@ yp_when_node_statements_set(yp_when_node_t *node, yp_statements_node_t *statemen
 
 // Allocate a new WhileNode node.
 static yp_while_node_t *
-yp_while_node_create(yp_parser_t *parser, const yp_token_t *keyword, yp_node_t *predicate, yp_statements_node_t *statements, yp_node_flags_t flags) {
+yp_while_node_create(yp_parser_t *parser, const yp_token_t *keyword, const yp_token_t *closing, yp_node_t *predicate, yp_statements_node_t *statements, yp_node_flags_t flags) {
     yp_while_node_t *node = YP_ALLOC_NODE(parser, yp_while_node_t);
 
-    const char *start = NULL;
-    bool has_statements = (statements != NULL) && (statements->body.size != 0);
-    if (has_statements && (keyword->start > statements->base.location.start)) {
-        start = statements->base.location.start;
-    } else {
-        start = keyword->start;
-    }
+    *node = (yp_while_node_t) {
+        {
+            .type = YP_NODE_WHILE_NODE,
+            .flags = flags,
+            .location = {
+                .start = keyword->start,
+                .end = closing->end
+            },
+        },
+        .keyword_loc = YP_LOCATION_TOKEN_VALUE(keyword),
+        .closing_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
+        .predicate = predicate,
+        .statements = statements
+    };
 
-    const char *end = NULL;
-    if (has_statements && (predicate->location.end < statements->base.location.end)) {
-        end = statements->base.location.end;
-    } else {
-        end = predicate->location.end;
-    }
+    return node;
+}
+
+// Allocate a new WhileNode node.
+static yp_while_node_t *
+yp_while_node_modifier_create(yp_parser_t *parser, const yp_token_t *keyword, yp_node_t *predicate, yp_statements_node_t *statements, yp_node_flags_t flags) {
+    yp_while_node_t *node = YP_ALLOC_NODE(parser, yp_while_node_t);
 
     *node = (yp_while_node_t) {
         {
             .type = YP_NODE_WHILE_NODE,
             .flags = flags,
             .location = {
-                .start = start,
-                .end = end,
+                .start = statements->base.location.start,
+                .end = predicate->location.end
             },
         },
         .keyword_loc = YP_LOCATION_TOKEN_VALUE(keyword),
+        .closing_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
         .predicate = predicate,
         .statements = statements
     };
@@ -4340,13 +4436,15 @@ yp_parser_local_depth(yp_parser_t *parser, yp_token_t *token) {
 }
 
 // Add a local variable from a location to the current scope.
-static void
+static yp_constant_id_t
 yp_parser_local_add_location(yp_parser_t *parser, const char *start, const char *end) {
     yp_constant_id_t constant_id = yp_parser_constant_id_location(parser, start, end);
 
     if (!yp_constant_id_list_includes(&parser->current_scope->locals, constant_id)) {
         yp_constant_id_list_append(&parser->current_scope->locals, constant_id);
     }
+
+    return constant_id;
 }
 
 // Add a local variable from a token to the current scope.
@@ -4494,27 +4592,30 @@ yp_do_loop_stack_p(yp_parser_t *parser) {
 /* Lexer check helpers                                                        */
 /******************************************************************************/
 
-// Get the next character in the source starting from parser->current.end and
-// adding the given offset. If that position is beyond the end of the source
-// then return '\0'.
+// Get the next character in the source starting from +cursor+. If that position
+// is beyond the end of the source then return '\0'.
 static inline char
-peek_at(yp_parser_t *parser, size_t offset) {
-    if (parser->current.end + offset < parser->end) {
-        return parser->current.end[offset];
+peek_at(yp_parser_t *parser, const char *cursor) {
+    if (cursor < parser->end) {
+        return *cursor;
     } else {
         return '\0';
     }
 }
 
+// Get the next character in the source starting from parser->current.end and
+// adding the given offset. If that position is beyond the end of the source
+// then return '\0'.
+static inline char
+peek_offset(yp_parser_t *parser, ptrdiff_t offset) {
+    return peek_at(parser, parser->current.end + offset);
+}
+
 // Get the next character in the source starting from parser->current.end. If
 // that position is beyond the end of the source then return '\0'.
 static inline char
 peek(yp_parser_t *parser) {
-    if (parser->current.end < parser->end) {
-        return *parser->current.end;
-    } else {
-        return '\0';
-    }
+    return peek_at(parser, parser->current.end);
 }
 
 // Get the next string of length len in the source starting from parser->current.end.
@@ -4539,6 +4640,35 @@ match(yp_parser_t *parser, char value) {
     return false;
 }
 
+// Return the length of the line ending string starting at +cursor+, or 0 if it
+// is not a line ending. This function is intended to be CRLF/LF agnostic.
+static inline size_t
+match_eol_at(yp_parser_t *parser, const char *cursor) {
+    if (peek_at(parser, cursor) == '\n') {
+        return 1;
+    }
+    if (peek_at(parser, cursor) == '\r' && peek_at(parser, cursor + 1) == '\n') {
+        return 2;
+    }
+    return 0;
+}
+
+// Return the length of the line ending string starting at
+// parser->current.end + offset, or 0 if it is not a line ending. This function
+// is intended to be CRLF/LF agnostic.
+static inline size_t
+match_eol_offset(yp_parser_t *parser, ptrdiff_t offset) {
+    return match_eol_at(parser, parser->current.end + offset);
+}
+
+// Return the length of the line ending string starting at parser->current.end,
+// or 0 if it is not a line ending. This function is intended to be CRLF/LF
+// agnostic.
+static inline size_t
+match_eol(yp_parser_t *parser) {
+    return match_eol_at(parser, parser->current.end);
+}
+
 // Skip to the next newline character or NUL byte.
 static inline const char *
 next_newline(const char *cursor, ptrdiff_t length) {
@@ -4562,11 +4692,13 @@ parser_lex_encoding_comment_start(yp_parser_t *parser, const char *cursor, ptrdi
 
     const char *cursor_limit = cursor + length - key_length + 1;
     while ((cursor = yp_memchr(cursor, 'c', (size_t) (cursor_limit - cursor), parser->encoding_changed, &parser->encoding)) != NULL) {
-        if (
-            (strncmp(cursor, "coding", key_length - 1) == 0) &&
-            (cursor[key_length - 1] == ':' || cursor[key_length - 1] == '=')
-        ) {
-            return cursor + key_length;
+        if (strncmp(cursor, "coding", key_length - 1) == 0) {
+            size_t whitespace_after_coding = yp_strspn_inline_whitespace(cursor + key_length - 1, parser->end - (cursor + key_length - 1));
+            size_t cur_pos = key_length + whitespace_after_coding;
+
+            if (cursor[cur_pos - 1] == ':' || cursor[cur_pos - 1] == '=') {
+                return cursor + cur_pos;
+            }
         }
 
         cursor++;
@@ -4822,7 +4954,7 @@ lex_optional_float_suffix(yp_parser_t *parser) {
     // Here we're going to attempt to parse the optional decimal portion of a
     // float. If it's not there, then it's okay and we'll just continue on.
     if (peek(parser) == '.') {
-        if (yp_char_is_decimal_digit(peek_at(parser, 1))) {
+        if (yp_char_is_decimal_digit(peek_offset(parser, 1))) {
             parser->current.end += 2;
             parser->current.end += yp_strspn_decimal_number(parser->current.end, parser->end - parser->current.end);
             type = YP_TOKEN_FLOAT;
@@ -4855,7 +4987,7 @@ static yp_token_type_t
 lex_numeric_prefix(yp_parser_t *parser) {
     yp_token_type_t type = YP_TOKEN_INTEGER;
 
-    if (parser->current.end[-1] == '0') {
+    if (peek_offset(parser, -1) == '0') {
         switch (*parser->current.end) {
             // 0d1111 is a decimal number
             case 'd':
@@ -4938,7 +5070,7 @@ lex_numeric_prefix(yp_parser_t *parser) {
 
     // If the last character that we consumed was an underscore, then this is
     // actually an invalid integer value, and we should return an invalid token.
-    if (parser->current.end[-1] == '_') {
+    if (peek_offset(parser, -1) == '_') {
         yp_diagnostic_list_append(&parser->error_list, parser->current.start, parser->current.end, "Number literal cannot end with a `_`.");
     }
 
@@ -5119,7 +5251,7 @@ lex_identifier(yp_parser_t *parser, bool previous_command_start) {
 
             if (
                 ((lex_state_p(parser, YP_LEX_STATE_LABEL | YP_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser)) &&
-                (peek(parser) == ':') && (peek_at(parser, 1) != ':')
+                (peek(parser) == ':') && (peek_offset(parser, 1) != ':')
             ) {
                 // If we're in a position where we can accept a : at the end of an
                 // identifier, then we'll optionally accept it.
@@ -5135,7 +5267,7 @@ lex_identifier(yp_parser_t *parser, bool previous_command_start) {
             }
 
             return YP_TOKEN_IDENTIFIER;
-        } else if (lex_state_p(parser, YP_LEX_STATE_FNAME) && peek_at(parser, 1) != '~' && peek_at(parser, 1) != '>' && (peek_at(parser, 1) != '=' || peek_at(parser, 2) == '>') && match(parser, '=')) {
+        } else if (lex_state_p(parser, YP_LEX_STATE_FNAME) && peek_offset(parser, 1) != '~' && peek_offset(parser, 1) != '>' && (peek_offset(parser, 1) != '=' || peek_offset(parser, 2) == '>') && match(parser, '=')) {
             // If we're in a position where we can accept a = at the end of an
             // identifier, then we'll optionally accept it.
             return YP_TOKEN_IDENTIFIER;
@@ -5143,7 +5275,7 @@ lex_identifier(yp_parser_t *parser, bool previous_command_start) {
 
         if (
             ((lex_state_p(parser, YP_LEX_STATE_LABEL | YP_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser)) &&
-            peek(parser) == ':' && peek_at(parser, 1) != ':'
+            peek(parser) == ':' && peek_offset(parser, 1) != ':'
         ) {
             // If we're in a position where we can accept a : at the end of an
             // identifier, then we'll optionally accept it.
@@ -5411,7 +5543,7 @@ lex_question_mark(yp_parser_t *parser) {
 
     if (parser->current.start[1] == '\\') {
         lex_state_set(parser, YP_LEX_STATE_END);
-        parser->current.end += yp_unescape_calculate_difference(parser->current.start + 1, parser->end, YP_UNESCAPE_ALL, true, &parser->error_list);
+        parser->current.end += yp_unescape_calculate_difference(parser, parser->current.start + 1, YP_UNESCAPE_ALL, true);
         return YP_TOKEN_CHARACTER_LITERAL;
     } else {
         size_t encoding_width = parser->encoding.char_width(parser->current.end, parser->end - parser->current.end);
@@ -5420,7 +5552,7 @@ lex_question_mark(yp_parser_t *parser) {
         // an underscore. We check for this case
         if (
             !(parser->encoding.alnum_char(parser->current.end, parser->end - parser->current.end) ||
-                *parser->current.end == '_') ||
+              peek(parser) == '_') ||
             (
                 (parser->current.end + encoding_width >= parser->end) ||
                 !char_is_identifier(parser, parser->current.end + encoding_width)
@@ -5636,28 +5768,32 @@ parser_lex(yp_parser_t *parser) {
                         space_seen = true;
                         break;
                     case '\r':
-                        if (peek_at(parser, 1) == '\n') {
+                        if (match_eol_offset(parser, 1)) {
                             chomping = false;
                         } else {
                             parser->current.end++;
                             space_seen = true;
                         }
                         break;
-                    case '\\':
-                        if (peek_at(parser, 1) == '\n') {
-                            yp_newline_list_append(&parser->newline_list, parser->current.end + 1);
-                            parser->current.end += 2;
-                            space_seen = true;
-                        } else if (parser->current.end + 2 < parser->end && peek_at(parser, 1) == '\r' && peek_at(parser, 2) == '\n') {
-                            yp_newline_list_append(&parser->newline_list, parser->current.end + 2);
-                            parser->current.end += 3;
-                            space_seen = true;
+                    case '\\': {
+                        size_t eol_length = match_eol_offset(parser, 1);
+                        if (eol_length) {
+                            if (parser->heredoc_end) {
+                                parser->current.end = parser->heredoc_end;
+                                parser->heredoc_end = NULL;
+                            } else {
+                                parser->current.end += eol_length + 1;
+                                yp_newline_list_append(&parser->newline_list, parser->current.end - 1);
+                                space_seen = true;
+                            }
                         } else if (yp_char_is_inline_whitespace(*parser->current.end)) {
                             parser->current.end += 2;
                         } else {
                             chomping = false;
                         }
+
                         break;
+                    }
                     default:
                         chomping = false;
                         break;
@@ -5667,13 +5803,14 @@ parser_lex(yp_parser_t *parser) {
             // Next, we'll set to start of this token to be the current end.
             parser->current.start = parser->current.end;
 
-            // We'll check if we're at the end of the file. If we are, then we need to
-            // return the EOF token.
+            // We'll check if we're at the end of the file. If we are, then we
+            // need to return the EOF token.
             if (parser->current.end >= parser->end) {
                 LEX(YP_TOKEN_EOF);
             }
 
-            // Finally, we'll check the current character to determine the next token.
+            // Finally, we'll check the current character to determine the next
+            // token.
             switch (*parser->current.end++) {
                 case '\0':   // NUL or end of script
                 case '\004': // ^D
@@ -5683,16 +5820,14 @@ parser_lex(yp_parser_t *parser) {
 
                 case '#': { // comments
                     const char *ending = next_newline(parser->current.end, parser->end - parser->current.end);
-                    while (ending && ending < parser->end && *ending != '\n') {
-                        ending = next_newline(ending + 1, parser->end - ending);
-                    }
 
                     parser->current.end = ending == NULL ? parser->end : ending + 1;
                     parser->current.type = YP_TOKEN_COMMENT;
                     parser_lex_callback(parser);
 
-                    // If we found a comment while lexing, then we're going to add it to the
-                    // list of comments in the file and keep lexing.
+                    // If we found a comment while lexing, then we're going to
+                    // add it to the list of comments in the file and keep
+                    // lexing.
                     yp_comment_t *comment = parser_comment(parser, YP_COMMENT_INLINE);
                     yp_list_append(&parser->comment_list, (yp_list_node_t *) comment);
 
@@ -5703,21 +5838,29 @@ parser_lex(yp_parser_t *parser) {
                     lexed_comment = true;
                 }
                 /* fallthrough */
-                case '\r': {
-                    // The only way you can have carriage returns in this particular loop
-                    // is if you have a carriage return followed by a newline. In that
-                    // case we'll just skip over the carriage return and continue lexing,
-                    // in order to make it so that the newline token encapsulates both the
-                    // carriage return and the newline. Note that we need to check that
-                    // we haven't already lexed a comment here because that falls through
-                    // into here as well.
-                    if (!lexed_comment) parser->current.end++;
-                }
-                /* fallthrough */
+                case '\r':
                 case '\n': {
-                    if (parser->heredoc_end == NULL) {
-                        yp_newline_list_append(&parser->newline_list, parser->current.end - 1);
-                    } else {
+                    size_t eol_length = match_eol_at(parser, parser->current.end - 1);
+                    if (eol_length) {
+                        // The only way you can have carriage returns in this
+                        // particular loop is if you have a carriage return
+                        // followed by a newline. In that case we'll just skip
+                        // over the carriage return and continue lexing, in
+                        // order to make it so that the newline token
+                        // encapsulates both the carriage return and the
+                        // newline. Note that we need to check that we haven't
+                        // already lexed a comment here because that falls
+                        // through into here as well.
+                        if (!lexed_comment) {
+                            parser->current.end += eol_length - 1; // skip CR
+                        }
+
+                        if (parser->heredoc_end == NULL) {
+                            yp_newline_list_append(&parser->newline_list, parser->current.end - 1);
+                        }
+                    }
+
+                    if (parser->heredoc_end) {
                         parser_flush_heredoc_end(parser);
                     }
 
@@ -5773,7 +5916,13 @@ parser_lex(yp_parser_t *parser) {
 
                             // If the lex state was ignored, or we hit a '.' or a '&.',
                             // we will lex the ignored newline
-                            if (lex_state_ignored_p(parser) || (following && ((following[0] == '.') || (following + 1 < parser->end && following[0] == '&' && following[1] == '.')))) {
+                            if (
+                                lex_state_ignored_p(parser) ||
+                                (following && (
+                                    (peek_at(parser, following) == '.') ||
+                                    (peek_at(parser, following) == '&' && peek_at(parser, following + 1) == '.')
+                                ))
+                            ) {
                                 if (!lexed_comment) parser_lex_ignored_newline(parser);
                                 lexed_comment = false;
                                 goto lex_next_token;
@@ -5786,7 +5935,7 @@ parser_lex(yp_parser_t *parser) {
                             // To match ripper, we need to emit an ignored newline even though
                             // its a real newline in the case that we have a beginless range
                             // on a subsequent line.
-                            if ((next_content + 1 < parser->end) && (next_content[1] == '.')) {
+                            if (peek_at(parser, next_content + 1) == '.') {
                                 if (!lexed_comment) parser_lex_ignored_newline(parser);
                                 lex_state_set(parser, YP_LEX_STATE_BEG);
                                 parser->command_start = true;
@@ -5804,7 +5953,7 @@ parser_lex(yp_parser_t *parser) {
 
                         // If we hit a &. after a newline, then we're in a call chain and
                         // we need to return the call operator.
-                        if (next_content + 1 < parser->end && next_content[0] == '&' && next_content[1] == '.') {
+                        if (peek_at(parser, next_content) == '&' && peek_at(parser, next_content + 1) == '.') {
                             if (!lexed_comment) parser_lex_ignored_newline(parser);
                             lex_state_set(parser, YP_LEX_STATE_DOT);
                             parser->current.start = next_content;
@@ -6001,7 +6150,7 @@ parser_lex(yp_parser_t *parser) {
 
                 // = => =~ == === =begin
                 case '=':
-                    if (current_token_starts_line(parser) && strncmp(peek_string(parser, 5), "begin", 5) == 0 && yp_char_is_whitespace(peek_at(parser, 5))) {
+                    if (current_token_starts_line(parser) && strncmp(peek_string(parser, 5), "begin", 5) == 0 && yp_char_is_whitespace(peek_offset(parser, 5))) {
                         yp_token_type_t type = lex_embdoc(parser);
 
                         if (type == YP_TOKEN_EOF) {
@@ -6425,13 +6574,13 @@ parser_lex(yp_parser_t *parser) {
                         LEX(YP_TOKEN_COLON_COLON);
                     }
 
-                    if (lex_state_end_p(parser) || yp_char_is_whitespace(*parser->current.end) || (*parser->current.end == '#')) {
+                    if (lex_state_end_p(parser) || yp_char_is_whitespace(*parser->current.end) || peek(parser) == '#') {
                         lex_state_set(parser, YP_LEX_STATE_BEG);
                         LEX(YP_TOKEN_COLON);
                     }
 
-                    if ((*parser->current.end == '"') || (*parser->current.end == '\'')) {
-                        lex_mode_push_string(parser, *parser->current.end == '"', false, '\0', *parser->current.end);
+                    if (peek(parser) == '"' || peek(parser) == '\'') {
+                        lex_mode_push_string(parser, peek(parser) == '"', false, '\0', *parser->current.end);
                         parser->current.end++;
                     }
 
@@ -6486,13 +6635,11 @@ parser_lex(yp_parser_t *parser) {
 
                 // % %= %i %I %q %Q %w %W
                 case '%': {
-                    // In a BEG state, if you encounter a % then you must be
-                    // starting something. In this case if there is no
-                    // subsequent character then we have an invalid token. We're
-                    // going to say it's the percent operator because we don't
-                    // want to move into the string lex mode unnecessarily.
-                    if (lex_state_beg_p(parser) && (parser->current.end >= parser->end)) {
-                        yp_diagnostic_list_append(&parser->error_list, parser->current.start, parser->current.end, "unexpected end of input");
+                    // If there is no subsequent character then we have an invalid token. We're
+                    // going to say it's the percent operator because we don't want to move into the
+                    // string lex mode unnecessarily.
+                    if ((lex_state_beg_p(parser) || lex_state_arg_p(parser)) && (parser->current.end >= parser->end)) {
+                        yp_diagnostic_list_append(&parser->error_list, parser->current.start, parser->current.end, "Unexpected end of input");
                         LEX(YP_TOKEN_PERCENT);
                     }
 
@@ -6502,25 +6649,26 @@ parser_lex(yp_parser_t *parser) {
                     }
                     else if(
                         lex_state_beg_p(parser) ||
-                        (lex_state_p(parser, YP_LEX_STATE_FITEM) && (*parser->current.end == 's')) ||
+                        (lex_state_p(parser, YP_LEX_STATE_FITEM) && (peek(parser) == 's')) ||
                         lex_state_spcarg_p(parser, space_seen)
                     ) {
                         if (!parser->encoding.alnum_char(parser->current.end, parser->end - parser->current.end)) {
                             lex_mode_push_string(parser, true, false, lex_mode_incrementor(*parser->current.end), lex_mode_terminator(*parser->current.end));
 
-                            if (*parser->current.end == '\r') {
+                            size_t eol_length = match_eol(parser);
+                            if (eol_length) {
+                                parser->current.end += eol_length;
+                                yp_newline_list_append(&parser->newline_list, parser->current.end - 1);
+                            } else {
                                 parser->current.end++;
                             }
 
-                            if (*parser->current.end == '\n') {
-                                yp_newline_list_append(&parser->newline_list, parser->current.end);
+                            if (parser->current.end < parser->end) {
+                                LEX(YP_TOKEN_STRING_BEGIN);
                             }
-
-                            parser->current.end++;
-                            LEX(YP_TOKEN_STRING_BEGIN);
                         }
 
-                        switch (*parser->current.end) {
+                        switch (peek(parser)) {
                             case 'i': {
                                 parser->current.end++;
 
@@ -6544,6 +6692,7 @@ parser_lex(yp_parser_t *parser) {
 
                                 if (parser->current.end < parser->end) {
                                     lex_mode_push_regexp(parser, lex_mode_incrementor(*parser->current.end), lex_mode_terminator(*parser->current.end));
+                                    yp_newline_list_check_append(&parser->newline_list, parser->current.end);
                                     parser->current.end++;
                                 }
 
@@ -6554,6 +6703,7 @@ parser_lex(yp_parser_t *parser) {
 
                                 if (parser->current.end < parser->end) {
                                     lex_mode_push_string(parser, false, false, lex_mode_incrementor(*parser->current.end), lex_mode_terminator(*parser->current.end));
+                                    yp_newline_list_check_append(&parser->newline_list, parser->current.end);
                                     parser->current.end++;
                                 }
 
@@ -6564,6 +6714,7 @@ parser_lex(yp_parser_t *parser) {
 
                                 if (parser->current.end < parser->end) {
                                     lex_mode_push_string(parser, true, false, lex_mode_incrementor(*parser->current.end), lex_mode_terminator(*parser->current.end));
+                                    yp_newline_list_check_append(&parser->newline_list, parser->current.end);
                                     parser->current.end++;
                                 }
 
@@ -6613,7 +6764,7 @@ parser_lex(yp_parser_t *parser) {
                                 // unparseable. In this case we'll just drop it from the parser
                                 // and skip past it and hope that the next token is something
                                 // that we can parse.
-                                yp_diagnostic_list_append(&parser->error_list, parser->current.start, parser->current.end, "invalid %% token");
+                                yp_diagnostic_list_append(&parser->error_list, parser->current.start, parser->current.end, "Invalid %% token");
                                 goto lex_next_token;
                         }
                     }
@@ -6665,8 +6816,9 @@ parser_lex(yp_parser_t *parser) {
                         ((parser->current.end - parser->current.start) == 7) &&
                         current_token_starts_line(parser) &&
                         (strncmp(parser->current.start, "__END__", 7) == 0) &&
-                        (*parser->current.end == '\n' || (*parser->current.end == '\r' && parser->current.end[1] == '\n'))
-                    ) {
+                        (parser->current.end == parser->end || match_eol(parser))
+                        )
+                    {
                         parser->current.end = parser->end;
                         parser->current.type = YP_TOKEN___END__;
                         parser_lex_callback(parser);
@@ -6723,7 +6875,7 @@ parser_lex(yp_parser_t *parser) {
 
             if ((whitespace = yp_strspn_whitespace_newlines(parser->current.end, parser->end - parser->current.end, &parser->newline_list, should_stop)) > 0) {
                 parser->current.end += whitespace;
-                if (parser->current.end[-1] == '\n') {
+                if (peek_offset(parser, -1) == '\n') {
                     // mutates next_start
                     parser_flush_heredoc_end(parser);
                 }
@@ -6787,13 +6939,11 @@ parser_lex(yp_parser_t *parser) {
                 // and find the next breakpoint.
                 if (*breakpoint == '\\') {
                     yp_unescape_type_t unescape_type = lex_mode->as.list.interpolation ? YP_UNESCAPE_ALL : YP_UNESCAPE_MINIMAL;
-                    size_t difference = yp_unescape_calculate_difference(breakpoint, parser->end, unescape_type, false, &parser->error_list);
+                    size_t difference = yp_unescape_calculate_difference(parser, breakpoint, unescape_type, false);
 
                     // If the result is an escaped newline, then we need to
                     // track that newline.
-                    if (breakpoint[difference - 1] == '\n') {
-                        yp_newline_list_append(&parser->newline_list, breakpoint + difference - 1);
-                    }
+                    yp_newline_list_check_append(&parser->newline_list, breakpoint + difference - 1);
 
                     breakpoint = yp_strpbrk(parser, breakpoint + difference, breakpoints, parser->end - (breakpoint + difference));
                     continue;
@@ -6828,7 +6978,13 @@ parser_lex(yp_parser_t *parser) {
 
         case YP_LEX_REGEXP: {
             // First, we'll set to start of this token to be the current end.
-            parser->current.start = parser->current.end;
+            if (parser->next_start == NULL) {
+                parser->current.start = parser->current.end;
+            } else {
+                parser->current.start = parser->next_start;
+                parser->current.end = parser->next_start;
+                parser->next_start = NULL;
+            }
 
             // We'll check if we're at the end of the file. If we are, then we need to
             // return the EOF token.
@@ -6855,7 +7011,16 @@ parser_lex(yp_parser_t *parser) {
                 // If we've hit a newline, then we need to track that in the
                 // list of newlines.
                 if (*breakpoint == '\n') {
-                    yp_newline_list_append(&parser->newline_list, breakpoint);
+                    // For the special case of a newline-terminated regular expression, we will pass
+                    // through this branch twice -- once with YP_TOKEN_REGEXP_BEGIN and then again
+                    // with YP_TOKEN_STRING_CONTENT. Let's avoid tracking the newline twice, by
+                    // tracking it only in the REGEXP_BEGIN case.
+                    if (
+                        !(lex_mode->as.regexp.terminator == '\n' && parser->current.type != YP_TOKEN_REGEXP_BEGIN)
+                        && parser->heredoc_end == NULL
+                    ) {
+                        yp_newline_list_append(&parser->newline_list, breakpoint);
+                    }
 
                     if (lex_mode->as.regexp.terminator != '\n') {
                         // If the terminator is not a newline, then we can set
@@ -6896,12 +7061,20 @@ parser_lex(yp_parser_t *parser) {
                 // literally. In this case we'll skip past the next character
                 // and find the next breakpoint.
                 if (*breakpoint == '\\') {
-                    size_t difference = yp_unescape_calculate_difference(breakpoint, parser->end, YP_UNESCAPE_ALL, false, &parser->error_list);
-
-                    // If the result is an escaped newline, then we need to
-                    // track that newline.
-                    if (breakpoint[difference - 1] == '\n') {
-                        yp_newline_list_append(&parser->newline_list, breakpoint + difference - 1);
+                    size_t difference = yp_unescape_calculate_difference(parser, breakpoint, YP_UNESCAPE_ALL, false);
+
+                    // If the result is an escaped newline ...
+                    if (*(breakpoint + difference - 1) == '\n') {
+                        if (parser->heredoc_end) {
+                            // ... if we are on the same line as a heredoc, flush the heredoc and
+                            // continue parsing after heredoc_end.
+                            parser->current.end = breakpoint + difference;
+                            parser_flush_heredoc_end(parser);
+                            LEX(YP_TOKEN_STRING_CONTENT);
+                        } else {
+                            // ... else track the newline.
+                            yp_newline_list_append(&parser->newline_list, breakpoint + difference - 1);
+                        }
                     }
 
                     breakpoint = yp_strpbrk(parser, breakpoint + difference, breakpoints, parser->end - (breakpoint + difference));
@@ -6989,21 +7162,18 @@ parser_lex(yp_parser_t *parser) {
 
                     // Otherwise we need to switch back to the parent lex mode and
                     // return the end of the string.
-                    if (*parser->current.end == '\r' && parser->current.end + 1 < parser->end && parser->current.end[1] == '\n') {
-                        parser->current.end = breakpoint + 2;
-                        yp_newline_list_append(&parser->newline_list, breakpoint + 1);
+                    size_t eol_length = match_eol_at(parser, breakpoint);
+                    if (eol_length) {
+                        parser->current.end = breakpoint + eol_length;
+                        yp_newline_list_append(&parser->newline_list, parser->current.end - 1);
                     } else {
-                        if (*parser->current.end == '\n') {
-                            yp_newline_list_append(&parser->newline_list, parser->current.end);
-                        }
-
                         parser->current.end = breakpoint + 1;
                     }
 
                     if (
                         parser->lex_modes.current->as.string.label_allowed &&
                         (peek(parser) == ':') &&
-                        (peek_at(parser, 1) != ':')
+                        (peek_offset(parser, 1) != ':')
                     ) {
                         parser->current.end++;
                         lex_state_set(parser, YP_LEX_STATE_ARG | YP_LEX_STATE_LABELED);
@@ -7041,12 +7211,20 @@ parser_lex(yp_parser_t *parser) {
                         // literally. In this case we'll skip past the next character and
                         // find the next breakpoint.
                         yp_unescape_type_t unescape_type = parser->lex_modes.current->as.string.interpolation ? YP_UNESCAPE_ALL : YP_UNESCAPE_MINIMAL;
-                        size_t difference = yp_unescape_calculate_difference(breakpoint, parser->end, unescape_type, false, &parser->error_list);
-
-                        // If the result is an escaped newline, then we need to
-                        // track that newline.
-                        if (breakpoint[difference - 1] == '\n') {
-                            yp_newline_list_append(&parser->newline_list, breakpoint + difference - 1);
+                        size_t difference = yp_unescape_calculate_difference(parser, breakpoint, unescape_type, false);
+
+                        // If the result is an escaped newline ...
+                        if (*(breakpoint + difference - 1) == '\n') {
+                            if (parser->heredoc_end) {
+                                // ... if we are on the same line as a heredoc, flush the heredoc and
+                                // continue parsing after heredoc_end.
+                                parser->current.end = breakpoint + difference;
+                                parser_flush_heredoc_end(parser);
+                                LEX(YP_TOKEN_STRING_CONTENT);
+                            } else {
+                                // ... else track the newline.
+                                yp_newline_list_append(&parser->newline_list, breakpoint + difference - 1);
+                            }
                         }
 
                         breakpoint = yp_strpbrk(parser, breakpoint + difference, breakpoints, parser->end - (breakpoint + difference));
@@ -7082,6 +7260,7 @@ parser_lex(yp_parser_t *parser) {
             } else {
                 parser->current.start = parser->next_start;
                 parser->current.end = parser->next_start;
+                parser->heredoc_end = NULL;
                 parser->next_start = NULL;
             }
 
@@ -7098,7 +7277,7 @@ parser_lex(yp_parser_t *parser) {
 
             // If we are immediately following a newline and we have hit the
             // terminator, then we need to return the ending of the heredoc.
-            if (parser->current.start[-1] == '\n') {
+            if (current_token_starts_line(parser)) {
                 const char *start = parser->current.start;
                 if (parser->lex_modes.current->as.heredoc.indent != YP_HEREDOC_INDENT_NONE) {
                     start += yp_strspn_inline_whitespace(start, parser->end - start);
@@ -7108,12 +7287,10 @@ parser_lex(yp_parser_t *parser) {
                     bool matched = true;
                     bool at_end = false;
 
-                    if ((start + ident_length < parser->end) && (start[ident_length] == '\n')) {
-                        parser->current.end = start + ident_length + 1;
-                        yp_newline_list_append(&parser->newline_list, start + ident_length);
-                    } else if ((start + ident_length + 1 < parser->end) && (start[ident_length] == '\r') && (start[ident_length + 1] == '\n')) {
-                        parser->current.end = start + ident_length + 2;
-                        yp_newline_list_append(&parser->newline_list, start + ident_length + 1);
+                    size_t eol_length = match_eol_at(parser, start + ident_length);
+                    if (eol_length) {
+                        parser->current.end = start + ident_length + eol_length;
+                        yp_newline_list_append(&parser->newline_list, parser->current.end - 1);
                     } else if (parser->end == (start + ident_length)) {
                         parser->current.end = start + ident_length;
                         at_end = true;
@@ -7178,19 +7355,10 @@ parser_lex(yp_parser_t *parser) {
                             (start + ident_length <= parser->end) &&
                             (strncmp(start, ident_start, ident_length) == 0)
                         ) {
-                            // Heredoc terminators must be followed by a newline or EOF to be valid.
-                            if (start + ident_length == parser->end || start[ident_length] == '\n') {
-                                parser->current.end = breakpoint + 1;
-                                LEX(YP_TOKEN_STRING_CONTENT);
-                            }
-
-                            // They can also be followed by a carriage return and then a
-                            // newline. Be sure here that we don't accidentally read off the
-                            // end.
+                            // Heredoc terminators must be followed by a newline, CRLF, or EOF to be valid.
                             if (
-                                (start + ident_length + 1 < parser->end) &&
-                                (start[ident_length] == '\r') &&
-                                (start[ident_length + 1] == '\n')
+                                start + ident_length == parser->end ||
+                                match_eol_at(parser, start + ident_length)
                             ) {
                                 parser->current.end = breakpoint + 1;
                                 LEX(YP_TOKEN_STRING_CONTENT);
@@ -7203,21 +7371,24 @@ parser_lex(yp_parser_t *parser) {
                         break;
                     }
                     case '\\': {
-                        // If we hit escapes, then we need to treat the next token
-                        // literally. In this case we'll skip past the next character and
-                        // find the next breakpoint.
-                        if (breakpoint[1] == '\n') {
-                            breakpoint++;
+                        // If we hit an escape, then we need to skip past
+                        // however many characters the escape takes up. However
+                        // it's important that if \n or \r\n are escaped that we
+                        // stop looping before the newline and not after the
+                        // newline so that we can still potentially find the
+                        // terminator of the heredoc.
+                        size_t eol_length = match_eol_at(parser, breakpoint + 1);
+                        if (eol_length) {
+                            breakpoint += eol_length;
                         } else {
                             yp_unescape_type_t unescape_type = (quote == YP_HEREDOC_QUOTE_SINGLE) ? YP_UNESCAPE_MINIMAL : YP_UNESCAPE_ALL;
-                            size_t difference = yp_unescape_calculate_difference(breakpoint, parser->end, unescape_type, false, &parser->error_list);
+                            size_t difference = yp_unescape_calculate_difference(parser, breakpoint, unescape_type, false);
 
-                            if (breakpoint[difference - 1] == '\n') {
-                                yp_newline_list_append(&parser->newline_list, breakpoint + difference - 1);
-                            }
+                            yp_newline_list_check_append(&parser->newline_list, breakpoint + difference - 1);
 
                             breakpoint = yp_strpbrk(parser, breakpoint + difference, breakpoints, parser->end - (breakpoint + difference));
                         }
+
                         break;
                     }
                     case '#': {
@@ -7264,10 +7435,10 @@ static yp_regular_expression_node_t *
 yp_regular_expression_node_create_and_unescape(yp_parser_t *parser, const yp_token_t *opening, const yp_token_t *content, const yp_token_t *closing, yp_unescape_type_t unescape_type) {
     yp_regular_expression_node_t *node = yp_regular_expression_node_create(parser, opening, content, closing);
 
-    ptrdiff_t length = content->end - content->start;
-    assert(length >= 0);
+    assert((content->end - content->start) >= 0);
+    yp_string_shared_init(&node->unescaped, content->start, content->end);
 
-    yp_unescape_manipulate_string(parser, content->start, (size_t) length, &node->unescaped, unescape_type, &parser->error_list);
+    yp_unescape_manipulate_string(parser, &node->unescaped, unescape_type);
     return node;
 }
 
@@ -7275,10 +7446,10 @@ static yp_symbol_node_t *
 yp_symbol_node_create_and_unescape(yp_parser_t *parser, const yp_token_t *opening, const yp_token_t *content, const yp_token_t *closing, yp_unescape_type_t unescape_type) {
     yp_symbol_node_t *node = yp_symbol_node_create(parser, opening, content, closing);
 
-    ptrdiff_t length = content->end - content->start;
-    assert(length >= 0);
+    assert((content->end - content->start) >= 0);
+    yp_string_shared_init(&node->unescaped, content->start, content->end);
 
-    yp_unescape_manipulate_string(parser, content->start, (size_t) length, &node->unescaped, unescape_type, &parser->error_list);
+    yp_unescape_manipulate_string(parser, &node->unescaped, unescape_type);
     return node;
 }
 
@@ -7286,10 +7457,10 @@ static yp_string_node_t *
 yp_string_node_create_and_unescape(yp_parser_t *parser, const yp_token_t *opening, const yp_token_t *content, const yp_token_t *closing, yp_unescape_type_t unescape_type) {
     yp_string_node_t *node = yp_string_node_create(parser, opening, content, closing);
 
-    ptrdiff_t length = content->end - content->start;
-    assert(length >= 0);
+    assert((content->end - content->start) >= 0);
+    yp_string_shared_init(&node->unescaped, content->start, content->end);
 
-    yp_unescape_manipulate_string(parser, content->start, (size_t) length, &node->unescaped, unescape_type, &parser->error_list);
+    yp_unescape_manipulate_string(parser, &node->unescaped, unescape_type);
     return node;
 }
 
@@ -7297,10 +7468,10 @@ static yp_x_string_node_t *
 yp_xstring_node_create_and_unescape(yp_parser_t *parser, const yp_token_t *opening, const yp_token_t *content, const yp_token_t *closing) {
     yp_x_string_node_t *node = yp_xstring_node_create(parser, opening, content, closing);
 
-    ptrdiff_t length = content->end - content->start;
-    assert(length >= 0);
+    assert((content->end - content->start) >= 0);
+    yp_string_shared_init(&node->unescaped, content->start, content->end);
 
-    yp_unescape_manipulate_string(parser, content->start, (size_t) length, &node->unescaped, YP_UNESCAPE_ALL, &parser->error_list);
+    yp_unescape_manipulate_string(parser, &node->unescaped, YP_UNESCAPE_ALL);
     return node;
 }
 
@@ -7652,19 +7823,153 @@ parse_starred_expression(yp_parser_t *parser, yp_binding_power_t binding_power,
 
 // Convert the given node into a valid target node.
 static yp_node_t *
-parse_target(yp_parser_t *parser, yp_node_t *target, yp_token_t *operator, yp_node_t *value) {
+parse_target(yp_parser_t *parser, yp_node_t *target) {
     switch (YP_NODE_TYPE(target)) {
         case YP_NODE_MISSING_NODE:
             return target;
-        case YP_NODE_CLASS_VARIABLE_READ_NODE: {
-            yp_class_variable_write_node_t *write_node = yp_class_variable_read_node_to_class_variable_write_node(parser, (yp_class_variable_read_node_t *) target, operator, value);
-            yp_node_destroy(parser, target);
-            return (yp_node_t *) write_node;
-        }
+        case YP_NODE_CLASS_VARIABLE_READ_NODE:
+            assert(sizeof(yp_class_variable_target_node_t) == sizeof(yp_class_variable_read_node_t));
+            target->type = YP_NODE_CLASS_VARIABLE_TARGET_NODE;
+            return target;
         case YP_NODE_CONSTANT_PATH_NODE:
-            return (yp_node_t *) yp_constant_path_write_node_create(parser, (yp_constant_path_node_t *) target, operator, value);
-        case YP_NODE_CONSTANT_READ_NODE: {
-            yp_constant_write_node_t *node = yp_constant_write_node_create(parser, &target->location, operator, value);
+            assert(sizeof(yp_constant_path_target_node_t) == sizeof(yp_constant_path_node_t));
+            target->type = YP_NODE_CONSTANT_PATH_TARGET_NODE;
+            return target;
+        case YP_NODE_CONSTANT_READ_NODE:
+            assert(sizeof(yp_constant_target_node_t) == sizeof(yp_constant_read_node_t));
+            target->type = YP_NODE_CONSTANT_TARGET_NODE;
+            return target;
+        case YP_NODE_BACK_REFERENCE_READ_NODE:
+            assert(sizeof(yp_global_variable_target_node_t) == sizeof(yp_back_reference_read_node_t));
+            /* fallthrough */
+        case YP_NODE_NUMBERED_REFERENCE_READ_NODE:
+            assert(sizeof(yp_global_variable_target_node_t) == sizeof(yp_numbered_reference_read_node_t));
+            yp_diagnostic_list_append(&parser->error_list, target->location.start, target->location.end, "Can't set variable");
+            /* fallthrough */
+        case YP_NODE_GLOBAL_VARIABLE_READ_NODE:
+            assert(sizeof(yp_global_variable_target_node_t) == sizeof(yp_global_variable_read_node_t));
+            target->type = YP_NODE_GLOBAL_VARIABLE_TARGET_NODE;
+            return target;
+        case YP_NODE_LOCAL_VARIABLE_READ_NODE:
+            assert(sizeof(yp_local_variable_target_node_t) == sizeof(yp_local_variable_read_node_t));
+            target->type = YP_NODE_LOCAL_VARIABLE_TARGET_NODE;
+            return target;
+        case YP_NODE_INSTANCE_VARIABLE_READ_NODE:
+            assert(sizeof(yp_instance_variable_target_node_t) == sizeof(yp_instance_variable_read_node_t));
+            target->type = YP_NODE_INSTANCE_VARIABLE_TARGET_NODE;
+            return target;
+        case YP_NODE_MULTI_WRITE_NODE:
+            return target;
+        case YP_NODE_SPLAT_NODE: {
+            yp_splat_node_t *splat = (yp_splat_node_t *) target;
+
+            if (splat->expression != NULL) {
+                splat->expression = parse_target(parser, splat->expression);
+            }
+
+            yp_token_t operator = not_provided(parser);
+            yp_location_t location = { .start = NULL, .end = NULL };
+
+            yp_multi_write_node_t *multi_write = yp_multi_write_node_create(parser, &operator, NULL, &location, &location);
+            yp_multi_write_node_targets_append(multi_write, (yp_node_t *) splat);
+
+            return (yp_node_t *) multi_write;
+        }
+        case YP_NODE_CALL_NODE: {
+            yp_call_node_t *call = (yp_call_node_t *) target;
+
+            // If we have no arguments to the call node and we need this to be a
+            // target then this is either a method call or a local variable write.
+            if (
+                (call->opening_loc.start == NULL) &&
+                (call->arguments == NULL) &&
+                (call->block == NULL)
+            ) {
+                if (call->receiver == NULL) {
+                    // When we get here, we have a local variable write, because it
+                    // was previously marked as a method call but now we have an =.
+                    // This looks like:
+                    //
+                    //     foo = 1
+                    //
+                    // When it was parsed in the prefix position, foo was seen as a
+                    // method call with no receiver and no arguments. Now we have an
+                    // =, so we know it's a local variable write.
+                    const yp_location_t message = call->message_loc;
+
+                    yp_parser_local_add_location(parser, message.start, message.end);
+                    yp_node_destroy(parser, target);
+
+                    const yp_token_t name = { .type = YP_TOKEN_IDENTIFIER, .start = message.start, .end = message.end };
+                    target = (yp_node_t *) yp_local_variable_read_node_create(parser, &name, 0);
+
+                    assert(sizeof(yp_local_variable_target_node_t) == sizeof(yp_local_variable_read_node_t));
+                    target->type = YP_NODE_LOCAL_VARIABLE_TARGET_NODE;
+
+                    if (token_is_numbered_parameter(message.start, message.end)) {
+                        yp_diagnostic_list_append(&parser->error_list, message.start, message.end, "reserved for numbered parameter");
+                    }
+
+                    return target;
+                }
+
+                // The method name needs to change. If we previously had foo, we now
+                // need foo=. In this case we'll allocate a new owned string, copy
+                // the previous method name in, and append an =.
+                size_t length = yp_string_length(&call->name);
+
+                char *name = calloc(length + 2, sizeof(char));
+                if (name == NULL) return NULL;
+
+                snprintf(name, length + 2, "%.*s=", (int) length, yp_string_source(&call->name));
+
+                // Now switch the name to the new string.
+                yp_string_free(&call->name);
+                yp_string_owned_init(&call->name, name, length + 1);
+
+                return target;
+            }
+
+            // If there is no call operator and the message is "[]" then this is
+            // an aref expression, and we can transform it into an aset
+            // expression.
+            if (
+                (call->operator_loc.start == NULL) &&
+                (call->message_loc.start[0] == '[') &&
+                (call->message_loc.end[-1] == ']') &&
+                (call->block == NULL)
+            ) {
+                // Free the previous name and replace it with "[]=".
+                yp_string_free(&call->name);
+                yp_string_constant_init(&call->name, "[]=", 3);
+                return target;
+            }
+        }
+        /* fallthrough */
+        default:
+            // In this case we have a node that we don't know how to convert
+            // into a target. We need to treat it as an error. For now, we'll
+            // mark it as an error and just skip right past it.
+            yp_diagnostic_list_append(&parser->error_list, target->location.start, target->location.end, "Unexpected write target.");
+            return target;
+    }
+}
+
+// Convert the given node into a valid write node.
+static yp_node_t *
+parse_write(yp_parser_t *parser, yp_node_t *target, yp_token_t *operator, yp_node_t *value) {
+    switch (YP_NODE_TYPE(target)) {
+        case YP_NODE_MISSING_NODE:
+            return target;
+        case YP_NODE_CLASS_VARIABLE_READ_NODE: {
+            yp_class_variable_write_node_t *write_node = yp_class_variable_read_node_to_class_variable_write_node(parser, (yp_class_variable_read_node_t *) target, operator, value);
+            yp_node_destroy(parser, target);
+            return (yp_node_t *) write_node;
+        }
+        case YP_NODE_CONSTANT_PATH_NODE:
+            return (yp_node_t *) yp_constant_path_write_node_create(parser, (yp_constant_path_node_t *) target, operator, value);
+        case YP_NODE_CONSTANT_READ_NODE: {
+            yp_constant_write_node_t *node = yp_constant_write_node_create(parser, &target->location, operator, value);
             yp_node_destroy(parser, target);
 
             return (yp_node_t *) node;
@@ -7699,18 +8004,15 @@ parse_target(yp_parser_t *parser, yp_node_t *target, yp_token_t *operator, yp_no
             yp_multi_write_node_t *multi_write = (yp_multi_write_node_t *) target;
             yp_multi_write_node_operator_loc_set(multi_write, operator);
 
-            if (value != NULL) {
-                multi_write->value = value;
-                multi_write->base.location.end = value->location.end;
-            }
-
+            multi_write->value = value;
+            multi_write->base.location.end = value->location.end;
             return (yp_node_t *) multi_write;
         }
         case YP_NODE_SPLAT_NODE: {
             yp_splat_node_t *splat = (yp_splat_node_t *) target;
 
             if (splat->expression != NULL) {
-                splat->expression = parse_target(parser, splat->expression, operator, value);
+                splat->expression = parse_write(parser, splat->expression, operator, value);
             }
 
             yp_location_t location = { .start = NULL, .end = NULL };
@@ -7763,12 +8065,10 @@ parse_target(yp_parser_t *parser, yp_node_t *target, yp_token_t *operator, yp_no
                 // method call with no arguments. Now we have an =, so we know it's
                 // a method call with an argument. In this case we will create the
                 // arguments node, parse the argument, and add it to the list.
-                if (value) {
-                    yp_arguments_node_t *arguments = yp_arguments_node_create(parser);
-                    call->arguments = arguments;
-                    yp_arguments_node_arguments_append(arguments, value);
-                    target->location.end = arguments->base.location.end;
-                }
+                yp_arguments_node_t *arguments = yp_arguments_node_create(parser);
+                call->arguments = arguments;
+                yp_arguments_node_arguments_append(arguments, value);
+                target->location.end = arguments->base.location.end;
 
                 // The method name needs to change. If we previously had foo, we now
                 // need foo=. In this case we'll allocate a new owned string, copy
@@ -7796,15 +8096,13 @@ parse_target(yp_parser_t *parser, yp_node_t *target, yp_token_t *operator, yp_no
                 (call->message_loc.end[-1] == ']') &&
                 (call->block == NULL)
             ) {
-                if (value != NULL) {
-                    if (call->arguments == NULL) {
-                        call->arguments = yp_arguments_node_create(parser);
-                    }
-
-                    yp_arguments_node_arguments_append(call->arguments, value);
-                    target->location.end = value->location.end;
+                if (call->arguments == NULL) {
+                    call->arguments = yp_arguments_node_create(parser);
                 }
 
+                yp_arguments_node_arguments_append(call->arguments, value);
+                target->location.end = value->location.end;
+
                 // Free the previous name and replace it with "[]=".
                 yp_string_free(&call->name);
                 yp_string_constant_init(&call->name, "[]=", 3);
@@ -7816,9 +8114,7 @@ parse_target(yp_parser_t *parser, yp_node_t *target, yp_token_t *operator, yp_no
             // syntax error. In this case we'll fall through to our default
             // handling. We need to free the value that we parsed because there
             // is no way for us to attach it to the tree at this point.
-            if (value != NULL) {
-                yp_node_destroy(parser, value);
-            }
+            yp_node_destroy(parser, value);
         }
         /* fallthrough */
         default:
@@ -7846,7 +8142,7 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
     // location that we know requires a multi write, as in the case of a for loop.
     // In this case we will set up the parsing loop slightly differently.
     if (first_target != NULL) {
-        first_target = parse_target(parser, first_target, &operator, NULL);
+        first_target = parse_target(parser, first_target);
 
         if (!match_type_p(parser, YP_TOKEN_COMMA)) {
             return first_target;
@@ -7877,9 +8173,8 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
                 yp_node_t *name = NULL;
 
                 if (token_begins_expression_p(parser->current.type)) {
-                    yp_token_t operator = not_provided(parser);
                     name = parse_expression(parser, binding_power, "Expected an expression after '*'.");
-                    name = parse_target(parser, name, &operator, NULL);
+                    name = parse_target(parser, name);
                 }
 
                 yp_node_t *splat = (yp_node_t *) yp_splat_node_create(parser, &star_operator, name);
@@ -7909,6 +8204,8 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
 
                     if (YP_NODE_TYPE_P(child_target, YP_NODE_MULTI_WRITE_NODE)) {
                         target = (yp_multi_write_node_t *) child_target;
+                        target->base.location.start = lparen.start;
+                        target->base.location.end = rparen.end;
                         target->lparen_loc = (yp_location_t) { .start = lparen.start, .end = lparen.end };
                         target->rparen_loc = (yp_location_t) { .start = rparen.start, .end = rparen.end };
                     } else {
@@ -7925,6 +8222,7 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
                         yp_multi_write_node_targets_append(target, child_target);
                     }
 
+                    target->base.location.start = lparen.start;
                     target->base.location.end = rparen.end;
                     yp_multi_write_node_targets_append(result, (yp_node_t *) target);
                 }
@@ -7947,7 +8245,7 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
                 }
 
                 yp_node_t *target = parse_expression(parser, binding_power, "Expected another expression after ','.");
-                target = parse_target(parser, target, &operator, NULL);
+                target = parse_target(parser, target);
 
                 yp_multi_write_node_targets_append(result, target);
             }
@@ -8407,7 +8705,6 @@ parse_parameters(
     bool looping = true;
 
     yp_do_loop_stack_push(parser, false);
-
     yp_parameters_order_t order = YP_PARAMETERS_ORDER_NONE;
 
     do {
@@ -8699,8 +8996,7 @@ parse_rescues(yp_parser_t *parser, yp_begin_node_t *parent_node) {
                 yp_rescue_node_operator_set(rescue, &parser->previous);
 
                 yp_node_t *reference = parse_expression(parser, YP_BINDING_POWER_INDEX, "Expected an exception variable after `=>` in rescue statement.");
-                yp_token_t operator = not_provided(parser);
-                reference = parse_target(parser, reference, &operator, NULL);
+                reference = parse_target(parser, reference);
 
                 yp_rescue_node_reference_set(rescue, reference);
                 break;
@@ -8730,8 +9026,7 @@ parse_rescues(yp_parser_t *parser, yp_begin_node_t *parent_node) {
                             yp_rescue_node_operator_set(rescue, &parser->previous);
 
                             yp_node_t *reference = parse_expression(parser, YP_BINDING_POWER_INDEX, "Expected an exception variable after `=>` in rescue statement.");
-                            yp_token_t operator = not_provided(parser);
-                            reference = parse_target(parser, reference, &operator, NULL);
+                            reference = parse_target(parser, reference);
 
                             yp_rescue_node_reference_set(rescue, reference);
                             break;
@@ -8999,7 +9294,7 @@ parse_conditional(yp_parser_t *parser, yp_context_t context) {
     }
 
     yp_token_t end_keyword = not_provided(parser);
-    yp_node_t *parent;
+    yp_node_t *parent = NULL;
 
     switch (context) {
         case YP_CONTEXT_IF:
@@ -9009,7 +9304,6 @@ parse_conditional(yp_parser_t *parser, yp_context_t context) {
             parent = (yp_node_t *) yp_unless_node_create(parser, &keyword, predicate, statements);
             break;
         default:
-            parent = NULL;
             assert(false && "unreachable");
             break;
     }
@@ -9055,50 +9349,49 @@ parse_conditional(yp_parser_t *parser, yp_context_t context) {
         switch (context) {
             case YP_CONTEXT_IF:
                 ((yp_if_node_t *) current)->consequent = (yp_node_t *) else_node;
-                // Recurse down if nodes setting the appropriate end location in
-                // all cases.
-                yp_node_t *recursing_node = parent;
-                bool recursing = true;
-
-                while (recursing) {
-                    switch (YP_NODE_TYPE(recursing_node)) {
-                        case YP_NODE_IF_NODE:
-                            yp_if_node_end_keyword_loc_set((yp_if_node_t *) recursing_node, &parser->previous);
-                            recursing_node = ((yp_if_node_t *) recursing_node)->consequent;
-                            break;
-                        case YP_NODE_ELSE_NODE:
-                            yp_else_node_end_keyword_loc_set((yp_else_node_t *) recursing_node, &parser->previous);
-                            recursing = false;
-                            break;
-                        default: {
-                            recursing = false;
-                            break;
-                        }
-                    }
-                }
                 break;
             case YP_CONTEXT_UNLESS:
                 ((yp_unless_node_t *) parent)->consequent = else_node;
-                yp_unless_node_end_keyword_loc_set((yp_unless_node_t *) parent, &parser->previous);
                 break;
             default:
                 assert(false && "unreachable");
                 break;
         }
     } else {
-        expect(parser, YP_TOKEN_KEYWORD_END, "Expected `end` to close `if` statement.");
+        expect(parser, YP_TOKEN_KEYWORD_END, "Expected `end` to close conditional statement.");
+    }
 
-        switch (context) {
-            case YP_CONTEXT_IF:
-                yp_if_node_end_keyword_loc_set((yp_if_node_t *) parent, &parser->previous);
-                break;
-            case YP_CONTEXT_UNLESS:
-                yp_unless_node_end_keyword_loc_set((yp_unless_node_t *) parent, &parser->previous);
-                break;
-            default:
-                assert(false && "unreachable");
-                break;
+    // Set the appropriate end location for all of the nodes in the subtree.
+    switch (context) {
+        case YP_CONTEXT_IF: {
+            yp_node_t *current = parent;
+            bool recursing = true;
+
+            while (recursing) {
+                switch (YP_NODE_TYPE(current)) {
+                    case YP_NODE_IF_NODE:
+                        yp_if_node_end_keyword_loc_set((yp_if_node_t *) current, &parser->previous);
+                        current = ((yp_if_node_t *) current)->consequent;
+                        recursing = current != NULL;
+                        break;
+                    case YP_NODE_ELSE_NODE:
+                        yp_else_node_end_keyword_loc_set((yp_else_node_t *) current, &parser->previous);
+                        recursing = false;
+                        break;
+                    default: {
+                        recursing = false;
+                        break;
+                    }
+                }
+            }
+            break;
         }
+        case YP_CONTEXT_UNLESS:
+            yp_unless_node_end_keyword_loc_set((yp_unless_node_t *) parent, &parser->previous);
+            break;
+        default:
+            assert(false && "unreachable");
+            break;
     }
 
     return parent;
@@ -9172,7 +9465,12 @@ parse_string_part(yp_parser_t *parser) {
             yp_unescape_type_t unescape_type = YP_UNESCAPE_ALL;
 
             if (parser->lex_modes.current->mode == YP_LEX_HEREDOC) {
-                if (parser->lex_modes.current->as.heredoc.quote == YP_HEREDOC_QUOTE_SINGLE) {
+                if (parser->lex_modes.current->as.heredoc.indent == YP_HEREDOC_INDENT_TILDE) {
+                    // If we're in a tilde heredoc, we want to unescape it later
+                    // because we don't want unescaped newlines to disappear
+                    // before we handle them in the dedent.
+                    unescape_type = YP_UNESCAPE_NONE;
+                } else if (parser->lex_modes.current->as.heredoc.quote == YP_HEREDOC_QUOTE_SINGLE) {
                     unescape_type = YP_UNESCAPE_MINIMAL;
                 }
             }
@@ -9280,14 +9578,10 @@ parse_string_part(yp_parser_t *parser) {
 
 static yp_node_t *
 parse_symbol(yp_parser_t *parser, yp_lex_mode_t *lex_mode, yp_lex_state_t next_state) {
-    bool lex_string = lex_mode->mode == YP_LEX_STRING;
-    bool can_be_interpolated = lex_string && lex_mode->as.string.interpolation;
     yp_token_t opening = parser->previous;
 
-    if (!lex_string) {
-        if (next_state != YP_LEX_STATE_NONE) {
-            lex_state_set(parser, next_state);
-        }
+    if (lex_mode->mode != YP_LEX_STRING) {
+        if (next_state != YP_LEX_STATE_NONE) lex_state_set(parser, next_state);
         yp_token_t symbol;
 
         switch (parser->current.type) {
@@ -9317,37 +9611,44 @@ parse_symbol(yp_parser_t *parser, yp_lex_mode_t *lex_mode, yp_lex_state_t next_s
         return (yp_node_t *) yp_symbol_node_create_and_unescape(parser, &opening, &symbol, &closing, YP_UNESCAPE_ALL);
     }
 
-    if (can_be_interpolated) {
-        // Create a node_list first. We'll use this to check if it should be an InterpolatedSymbolNode
-        // or a SymbolNode
+    if (lex_mode->as.string.interpolation) {
+        // If we have the end of the symbol, then we can return an empty symbol.
+        if (match_type_p(parser, YP_TOKEN_STRING_END)) {
+            if (next_state != YP_LEX_STATE_NONE) lex_state_set(parser, next_state);
+            parser_lex(parser);
+
+            yp_token_t content = not_provided(parser);
+            yp_token_t closing = parser->previous;
+            return (yp_node_t *) yp_symbol_node_create_and_unescape(parser, &opening, &content, &closing, YP_UNESCAPE_NONE);
+        }
+
+        // Now we can parse the first part of the symbol.
+        yp_node_t *part = parse_string_part(parser);
+
+        // If we got a string part, then it's possible that we could transform
+        // what looks like an interpolated symbol into a regular symbol.
+        if (part && YP_NODE_TYPE_P(part, YP_NODE_STRING_NODE) && match_any_type_p(parser, 2, YP_TOKEN_STRING_END, YP_TOKEN_EOF)) {
+            if (next_state != YP_LEX_STATE_NONE) lex_state_set(parser, next_state);
+            parser_lex(parser);
+
+            return (yp_node_t *) yp_string_node_to_symbol_node(parser, (yp_string_node_t *) part, &opening, &parser->previous);
+        }
+
+        // Create a node_list first. We'll use this to check if it should be an
+        // InterpolatedSymbolNode or a SymbolNode.
         yp_node_list_t node_list = YP_EMPTY_NODE_LIST;
+        if (part) yp_node_list_append(&node_list, part);
 
         while (!match_any_type_p(parser, 2, YP_TOKEN_STRING_END, YP_TOKEN_EOF)) {
-            yp_node_t *part = parse_string_part(parser);
-            if (part != NULL) {
+            if ((part = parse_string_part(parser)) != NULL) {
                 yp_node_list_append(&node_list, part);
             }
         }
 
-        yp_node_t *res;
-        // If the only element on the node_list is a StringNode, we know this is a SymbolNode
-        // and not an InterpolatedSymbolNode
-        if (node_list.size == 1 && YP_NODE_TYPE_P(node_list.nodes[0], YP_NODE_STRING_NODE)) {
-            res = (yp_node_t *)yp_string_node_to_symbol_node(parser, (yp_string_node_t *)node_list.nodes[0]);
-            free(node_list.nodes);
-        }
-        else {
-            yp_interpolated_symbol_node_t *interpolated = yp_interpolated_symbol_node_create(parser, &opening, &node_list, &opening);
-            yp_interpolated_symbol_node_closing_set(interpolated, &parser->current);
-            res = (yp_node_t *) interpolated;
-        }
-
-        if (next_state != YP_LEX_STATE_NONE) {
-            lex_state_set(parser, next_state);
-        }
+        if (next_state != YP_LEX_STATE_NONE) lex_state_set(parser, next_state);
         expect(parser, YP_TOKEN_STRING_END, "Expected a closing delimiter for an interpolated symbol.");
 
-        return res;
+        return (yp_node_t *) yp_interpolated_symbol_node_create(parser, &opening, &node_list, &parser->previous);
     }
 
     yp_token_t content;
@@ -9491,9 +9792,12 @@ parse_heredoc_common_whitespace(yp_parser_t *parser, yp_node_list_t *nodes) {
             const char *cur_char = content_loc->start;
 
             while (cur_char && cur_char < content_loc->end) {
-                // Any empty newlines aren't included in the minimum whitespace calculation
-                while (cur_char < content_loc->end && *cur_char == '\n') cur_char++;
-                while (cur_char + 1 < content_loc->end && *cur_char == '\r' && cur_char[1] == '\n') cur_char += 2;
+                // Any empty newlines aren't included in the minimum whitespace
+                // calculation.
+                size_t eol_length;
+                while ((eol_length = match_eol_at(parser, cur_char))) {
+                    cur_char += eol_length;
+                }
 
                 if (cur_char == content_loc->end) break;
 
@@ -9508,11 +9812,12 @@ parse_heredoc_common_whitespace(yp_parser_t *parser, yp_node_list_t *nodes) {
                     cur_char++;
                 }
 
-                // If we hit a newline, then we have encountered a line that contains
-                // only whitespace, and it shouldn't be considered in the calculation of
-                // common leading whitespace.
-                if (*cur_char == '\n') {
-                    cur_char++;
+                // If we hit a newline, then we have encountered a line that
+                // contains only whitespace, and it shouldn't be considered in
+                // the calculation of common leading whitespace.
+                eol_length = match_eol_at(parser, cur_char);
+                if (eol_length) {
+                    cur_char += eol_length;
                     continue;
                 }
 
@@ -9545,14 +9850,30 @@ parse_heredoc_dedent(yp_parser_t *parser, yp_node_t *node, yp_heredoc_quote_t qu
     int common_whitespace;
     if ((common_whitespace = parse_heredoc_common_whitespace(parser, nodes)) <= 0) return;
 
-    // Iterate over all nodes, and trim whitespace accordingly.
-    for (size_t index = 0; index < nodes->size; index++) {
-        yp_node_t *node = nodes->nodes[index];
-        if (!YP_NODE_TYPE_P(node, YP_NODE_STRING_NODE)) continue;
+    // The next node should be dedented if it's the first node in the list or if
+    // if follows a string node.
+    bool dedent_next = true;
+
+    // Iterate over all nodes, and trim whitespace accordingly. We're going to
+    // keep around two indices: a read and a write. If we end up trimming all of
+    // the whitespace from a node, then we'll drop it from the list entirely.
+    size_t write_index = 0;
+
+    for (size_t read_index = 0; read_index < nodes->size; read_index++) {
+        yp_node_t *node = nodes->nodes[read_index];
+
+        // We're not manipulating child nodes that aren't strings. In this case
+        // we'll skip past it and indicate that the subsequent node should not
+        // be dedented.
+        if (!YP_NODE_TYPE_P(node, YP_NODE_STRING_NODE)) {
+            nodes->nodes[write_index++] = node;
+            dedent_next = false;
+            continue;
+        }
 
         // Get a reference to the string struct that is being held by the string
         // node. This is the value we're going to actual manipulate.
-        yp_string_t *string = &((yp_string_node_t *) node)->unescaped;
+        yp_string_t *string = &(((yp_string_node_t *) node)->unescaped);
         yp_string_ensure_owned(string);
 
         // Now get the bounds of the existing string. We'll use this as a
@@ -9568,7 +9889,6 @@ parse_heredoc_dedent(yp_parser_t *parser, yp_node_t *node, yp_heredoc_quote_t qu
         // whitespace, so we'll maintain a pointer to the current position in the
         // string that we're writing to.
         char *dest_cursor = source_start;
-        bool dedent_next = (index == 0) || YP_NODE_TYPE_P(nodes->nodes[index - 1], YP_NODE_STRING_NODE);
 
         while (source_cursor < source_end) {
             // If we need to dedent the next element within the heredoc or the next
@@ -9613,8 +9933,20 @@ parse_heredoc_dedent(yp_parser_t *parser, yp_node_t *node, yp_heredoc_quote_t qu
             dedent_next = true;
         }
 
-        string->length = dest_length;
+        // We only want to write this node into the list if it has any content.
+        if (dest_length == 0) {
+            yp_node_destroy(parser, node);
+        } else {
+            string->length = dest_length;
+            yp_unescape_manipulate_string(parser, string, (quote == YP_HEREDOC_QUOTE_SINGLE) ? YP_UNESCAPE_MINIMAL : YP_UNESCAPE_ALL);
+            nodes->nodes[write_index++] = node;
+        }
+
+        // We always dedent the next node if it follows a string node.
+        dedent_next = true;
     }
+
+    nodes->size = write_index;
 }
 
 static yp_node_t *
@@ -10363,10 +10695,8 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
         }
         case YP_TOKEN_PARENTHESIS_LEFT:
         case YP_TOKEN_PARENTHESIS_LEFT_PARENTHESES: {
-            yp_token_type_t current_token_type = parser->current.type;
+            yp_token_t opening = parser->current;
             parser_lex(parser);
-
-            yp_token_t opening = parser->previous;
             while (accept_any(parser, 2, YP_TOKEN_SEMICOLON, YP_TOKEN_NEWLINE));
 
             // If this is the end of the file or we match a right parenthesis, then
@@ -10385,7 +10715,7 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
             // If we hit a right parenthesis, then we're done parsing the parentheses
             // node, and we can check which kind of node we should return.
             if (match_type_p(parser, YP_TOKEN_PARENTHESIS_RIGHT)) {
-                if (current_token_type == YP_TOKEN_PARENTHESIS_LEFT_PARENTHESES) {
+                if (opening.type == YP_TOKEN_PARENTHESIS_LEFT_PARENTHESES) {
                     lex_state_set(parser, YP_LEX_STATE_ENDARG);
                 }
                 parser_lex(parser);
@@ -10403,6 +10733,8 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
 
                         if (multi_statement->lparen_loc.start == NULL) {
                             multi_write = (yp_multi_write_node_t *) statement;
+                            multi_write->base.location.start = lparen_loc.start;
+                            multi_write->base.location.end = rparen_loc.end;
                             multi_write->lparen_loc = lparen_loc;
                             multi_write->rparen_loc = rparen_loc;
                         } else {
@@ -10505,7 +10837,7 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
             // fact a method call, not a constant read.
             if (
                 match_type_p(parser, YP_TOKEN_PARENTHESIS_LEFT) ||
-                (binding_power <= YP_BINDING_POWER_ASSIGNMENT && (token_begins_expression_p(parser->current.type) || match_any_type_p(parser, 2, YP_TOKEN_USTAR, YP_TOKEN_USTAR_STAR))) ||
+                (binding_power <= YP_BINDING_POWER_ASSIGNMENT && (token_begins_expression_p(parser->current.type) || match_any_type_p(parser, 3, YP_TOKEN_UAMPERSAND, YP_TOKEN_USTAR, YP_TOKEN_USTAR_STAR))) ||
                 (yp_accepts_block_stack_p(parser) && match_any_type_p(parser, 2, YP_TOKEN_KEYWORD_DO, YP_TOKEN_BRACE_LEFT))
             ) {
                 yp_arguments_t arguments = YP_EMPTY_ARGUMENTS;
@@ -10628,7 +10960,7 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
                 // can still be a method call if it is followed by arguments or
                 // a block, so we need to check for that here.
                 if (
-                    (binding_power <= YP_BINDING_POWER_ASSIGNMENT && (token_begins_expression_p(parser->current.type) || match_any_type_p(parser, 2, YP_TOKEN_USTAR, YP_TOKEN_USTAR_STAR))) ||
+                    (binding_power <= YP_BINDING_POWER_ASSIGNMENT && (token_begins_expression_p(parser->current.type) || match_any_type_p(parser, 3, YP_TOKEN_UAMPERSAND, YP_TOKEN_USTAR, YP_TOKEN_USTAR_STAR))) ||
                     (yp_accepts_block_stack_p(parser) && match_any_type_p(parser, 2, YP_TOKEN_KEYWORD_DO, YP_TOKEN_BRACE_LEFT))
                 ) {
                     yp_arguments_t arguments = YP_EMPTY_ARGUMENTS;
@@ -10673,12 +11005,15 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
 
             lex_state_set(parser, YP_LEX_STATE_END);
             expect(parser, YP_TOKEN_HEREDOC_END, "Expected a closing delimiter for heredoc.");
+
             if (quote == YP_HEREDOC_QUOTE_BACKTICK) {
                 assert(YP_NODE_TYPE_P(node, YP_NODE_INTERPOLATED_X_STRING_NODE));
                 yp_interpolated_xstring_node_closing_set(((yp_interpolated_x_string_node_t *) node), &parser->previous);
+                node->location = ((yp_interpolated_x_string_node_t *) node)->opening_loc;
             } else {
                 assert(YP_NODE_TYPE_P(node, YP_NODE_INTERPOLATED_STRING_NODE));
                 yp_interpolated_string_node_closing_set((yp_interpolated_string_node_t *) node, &parser->previous);
+                node->location = ((yp_interpolated_string_node_t *) node)->opening_loc;
             }
 
             // If this is a heredoc that is indented with a ~, then we need to dedent
@@ -11043,7 +11378,12 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
                 return (yp_node_t *) yp_singleton_class_node_create(parser, &locals, &class_keyword, &operator, expression, statements, &parser->previous);
             }
 
-            yp_node_t *name = parse_expression(parser, YP_BINDING_POWER_INDEX, "Expected to find a class name after `class`.");
+            yp_node_t *constant_path = parse_expression(parser, YP_BINDING_POWER_INDEX, "Expected to find a class name after `class`.");
+            yp_token_t name = parser->previous;
+            if (name.type != YP_TOKEN_CONSTANT) {
+                yp_diagnostic_list_append(&parser->error_list, name.start, name.end, "Expected a constant name after `class`.");
+            }
+
             yp_token_t inheritance_operator;
             yp_node_t *superclass;
 
@@ -11084,7 +11424,7 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
             yp_constant_id_list_t locals = parser->current_scope->locals;
             yp_parser_scope_pop(parser);
             yp_do_loop_stack_pop(parser);
-            return (yp_node_t *) yp_class_node_create(parser, &locals, &class_keyword, name, &inheritance_operator, superclass, statements, &parser->previous);
+            return (yp_node_t *) yp_class_node_create(parser, &locals, &class_keyword, constant_path, &name, &inheritance_operator, superclass, statements, &parser->previous);
         }
         case YP_TOKEN_KEYWORD_DEF: {
             yp_token_t def_keyword = parser->current;
@@ -11243,6 +11583,12 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
                     break;
                 }
                 case YP_CASE_PARAMETER: {
+                    // If we're about to lex a label, we need to add the label
+                    // state to make sure the next newline is ignored.
+                    if (parser->current.type == YP_TOKEN_LABEL) {
+                        lex_state_set(parser, parser->lex_state | YP_LEX_STATE_LABEL);
+                    }
+
                     lparen = not_provided(parser);
                     rparen = not_provided(parser);
                     params = parse_parameters(parser, YP_BINDING_POWER_DEFINED, false, false, true);
@@ -11472,13 +11818,14 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
             parser_lex(parser);
 
             yp_token_t module_keyword = parser->previous;
-            yp_node_t *name = parse_expression(parser, YP_BINDING_POWER_INDEX, "Expected to find a module name after `module`.");
+            yp_node_t *constant_path = parse_expression(parser, YP_BINDING_POWER_INDEX, "Expected to find a module name after `module`.");
+            yp_token_t name;
 
-            // If we can recover from a syntax error that occurred while parsing the
-            // name of the module, then we'll handle that here.
-            if (YP_NODE_TYPE_P(name, YP_NODE_MISSING_NODE)) {
-                yp_token_t end_keyword = (yp_token_t) { .type = YP_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
-                return (yp_node_t *) yp_module_node_create(parser, NULL, &module_keyword, name, NULL, &end_keyword);
+            // If we can recover from a syntax error that occurred while parsing
+            // the name of the module, then we'll handle that here.
+            if (YP_NODE_TYPE_P(constant_path, YP_NODE_MISSING_NODE)) {
+                yp_token_t missing = (yp_token_t) { .type = YP_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
+                return (yp_node_t *) yp_module_node_create(parser, NULL, &module_keyword, constant_path, &missing, NULL, &missing);
             }
 
             while (accept(parser, YP_TOKEN_COLON_COLON)) {
@@ -11487,7 +11834,15 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
                 expect(parser, YP_TOKEN_CONSTANT, "Expected to find a module name after `::`.");
                 yp_node_t *constant = (yp_node_t *) yp_constant_read_node_create(parser, &parser->previous);
 
-                name = (yp_node_t *)yp_constant_path_node_create(parser, name, &double_colon, constant);
+                constant_path = (yp_node_t *) yp_constant_path_node_create(parser, constant_path, &double_colon, constant);
+            }
+
+            // Here we retrieve the name of the module. If it wasn't a constant,
+            // then it's possible that `module foo` was passed, which is a
+            // syntax error. We handle that here as well.
+            name = parser->previous;
+            if (name.type != YP_TOKEN_CONSTANT) {
+                yp_diagnostic_list_append(&parser->error_list, name.start, name.end, "Expected to find a module name after `module`.");
             }
 
             yp_parser_scope_push(parser, true);
@@ -11514,7 +11869,7 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
                 yp_diagnostic_list_append(&parser->error_list, module_keyword.start, module_keyword.end, "Module definition in method body");
             }
 
-            return (yp_node_t *) yp_module_node_create(parser, &locals, &module_keyword, name, statements, &parser->previous);
+            return (yp_node_t *) yp_module_node_create(parser, &locals, &module_keyword, constant_path, &name, statements, &parser->previous);
         }
         case YP_TOKEN_KEYWORD_NIL:
             parser_lex(parser);
@@ -11550,12 +11905,7 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
                 expect(parser, YP_TOKEN_KEYWORD_END, "Expected `end` to close `until` statement.");
             }
 
-            yp_until_node_t *until_node = yp_until_node_create(parser, &keyword, predicate, statements, 0);
-            if (parser->previous.type == YP_TOKEN_KEYWORD_END) {
-                until_node->base.location.end = parser->previous.end;
-            }
-
-            return (yp_node_t *) until_node;
+            return (yp_node_t *) yp_until_node_create(parser, &keyword, &parser->previous, predicate, statements, 0);
         }
         case YP_TOKEN_KEYWORD_WHILE: {
             yp_do_loop_stack_push(parser, true);
@@ -11576,11 +11926,7 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
                 expect(parser, YP_TOKEN_KEYWORD_END, "Expected `end` to close `while` statement.");
             }
 
-            yp_while_node_t *while_node = yp_while_node_create(parser, &keyword, predicate, statements, 0);
-            if (parser->previous.type == YP_TOKEN_KEYWORD_END) {
-                while_node->base.location.end = parser->previous.end;
-            }
-            return (yp_node_t *) while_node;
+            return (yp_node_t *) yp_while_node_create(parser, &keyword, &parser->previous, predicate, statements, 0);
         }
         case YP_TOKEN_PERCENT_LOWER_I: {
             parser_lex(parser);
@@ -12086,30 +12432,32 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
             yp_accepts_block_stack_push(parser, true);
             parser_lex(parser);
 
-            yp_token_t opening = parser->previous;
+            yp_token_t operator = parser->previous;
             yp_parser_scope_push(parser, false);
             yp_block_parameters_node_t *params;
 
             switch (parser->current.type) {
                 case YP_TOKEN_PARENTHESIS_LEFT: {
-                    yp_token_t block_parameters_opening = parser->current;
+                    yp_token_t opening = parser->current;
                     parser_lex(parser);
 
                     if (match_type_p(parser, YP_TOKEN_PARENTHESIS_RIGHT)) {
-                        params = yp_block_parameters_node_create(parser, NULL, &block_parameters_opening);
+                        params = yp_block_parameters_node_create(parser, NULL, &opening);
                     } else {
-                        params = parse_block_parameters(parser, false, &block_parameters_opening, true);
+                        params = parse_block_parameters(parser, false, &opening, true);
                     }
 
                     accept(parser, YP_TOKEN_NEWLINE);
                     expect(parser, YP_TOKEN_PARENTHESIS_RIGHT, "Expected ')' after left parenthesis.");
-                    yp_block_parameters_node_closing_set(params, &parser->previous);
 
+                    yp_block_parameters_node_closing_set(params, &parser->previous);
                     break;
                 }
                 case YP_CASE_PARAMETER: {
+                    yp_accepts_block_stack_push(parser, false);
                     yp_token_t opening = not_provided(parser);
                     params = parse_block_parameters(parser, false, &opening, true);
+                    yp_accepts_block_stack_pop(parser);
                     break;
                 }
                 default: {
@@ -12118,16 +12466,20 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
                 }
             }
 
+            yp_token_t opening;
             yp_node_t *body = NULL;
             parser->lambda_enclosure_nesting = previous_lambda_enclosure_nesting;
 
             if (accept(parser, YP_TOKEN_LAMBDA_BEGIN)) {
+                opening = parser->previous;
+
                 if (!accept(parser, YP_TOKEN_BRACE_RIGHT)) {
                     body = (yp_node_t *) parse_statements(parser, YP_CONTEXT_LAMBDA_BRACES);
                     expect(parser, YP_TOKEN_BRACE_RIGHT, "Expecting '}' to close lambda block.");
                 }
             } else {
                 expect(parser, YP_TOKEN_KEYWORD_DO, "Expected a 'do' keyword or a '{' to open lambda block.");
+                opening = parser->previous;
 
                 if (!match_any_type_p(parser, 3, YP_TOKEN_KEYWORD_END, YP_TOKEN_KEYWORD_RESCUE, YP_TOKEN_KEYWORD_ENSURE)) {
                     body = (yp_node_t *) parse_statements(parser, YP_CONTEXT_LAMBDA_DO_END);
@@ -12144,7 +12496,7 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
             yp_constant_id_list_t locals = parser->current_scope->locals;
             yp_parser_scope_pop(parser);
             yp_accepts_block_stack_pop(parser);
-            return (yp_node_t *) yp_lambda_node_create(parser, &locals, &opening, params, body, &parser->previous);
+            return (yp_node_t *) yp_lambda_node_create(parser, &locals, &operator, &opening, &parser->previous, params, body);
         }
         case YP_TOKEN_UPLUS: {
             parser_lex(parser);
@@ -12363,7 +12715,7 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                 case YP_CASE_WRITABLE: {
                     parser_lex(parser);
                     yp_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, "Expected a value after =.");
-                    return parse_target(parser, node, &token, value);
+                    return parse_write(parser, node, &token, value);
                 }
                 case YP_NODE_SPLAT_NODE: {
                     yp_splat_node_t *splat_node = (yp_splat_node_t *) node;
@@ -12372,7 +12724,7 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                         case YP_CASE_WRITABLE:
                             parser_lex(parser);
                             yp_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, "Expected a value after =.");
-                            return parse_target(parser, (yp_node_t *) splat_node, &token, value);
+                            return parse_write(parser, (yp_node_t *) splat_node, &token, value);
                         default:
                             break;
                     }
@@ -12398,48 +12750,16 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                    yp_node_t *result = (yp_node_t *) yp_global_variable_operator_and_write_node_create(parser, node, &token, value);
+                    yp_node_t *result = (yp_node_t *) yp_global_variable_and_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
                 }
-                case YP_NODE_CALL_NODE: {
-                    yp_call_node_t *call_node = (yp_call_node_t *) node;
-
-                    // If we have a vcall (a method with no arguments and no
-                    // receiver that could have been a local variable) then we
-                    // will transform it into a local variable write.
-                    if (yp_call_node_variable_call_p(call_node)) {
-                        yp_location_t message_loc = call_node->message_loc;
-                        yp_parser_local_add_location(parser, message_loc.start, message_loc.end);
-
-                        if (token_is_numbered_parameter(message_loc.start, message_loc.end)) {
-                            yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter");
-                        }
-
-                        parser_lex(parser);
-
-                        yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                        yp_constant_id_t constant_id = yp_parser_constant_id_location(parser, message_loc.start, message_loc.end);
-                        yp_node_t *result = (yp_node_t *) yp_local_variable_operator_and_write_node_create(parser, node, &token, value, constant_id);
-
-                        yp_node_destroy(parser, node);
-                        return result;
-                    }
-
-                    parser_lex(parser);
-
-                    yp_token_t operator = not_provided(parser);
-                    node = parse_target(parser, node, &operator, NULL);
-
-                    yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                    return (yp_node_t *) yp_call_operator_and_write_node_create(parser, (yp_call_node_t *) node, &token, value);
-                }
                 case YP_NODE_CLASS_VARIABLE_READ_NODE: {
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                    yp_node_t *result = (yp_node_t *) yp_class_variable_operator_and_write_node_create(parser, node, &token, value);
+                    yp_node_t *result = (yp_node_t *) yp_class_variable_and_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
@@ -12448,13 +12768,13 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                    return (yp_node_t *) yp_constant_path_operator_and_write_node_create(parser, (yp_constant_path_node_t *) node, &token, value);
+                    return (yp_node_t *) yp_constant_path_and_write_node_create(parser, (yp_constant_path_node_t *) node, &token, value);
                 }
                 case YP_NODE_CONSTANT_READ_NODE: {
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                    yp_node_t *result = (yp_node_t *) yp_constant_operator_and_write_node_create(parser, node, &token, value);
+                    yp_node_t *result = (yp_node_t *) yp_constant_and_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
@@ -12463,21 +12783,49 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                    yp_node_t *result = (yp_node_t *) yp_instance_variable_operator_and_write_node_create(parser, node, &token, value);
+                    yp_node_t *result = (yp_node_t *) yp_instance_variable_and_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
                 }
                 case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
+                    yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node;
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                    yp_constant_id_t constant_id = ((yp_local_variable_read_node_t *) node)->constant_id;
-                    yp_node_t *result = (yp_node_t *) yp_local_variable_operator_and_write_node_create(parser, node, &token, value, constant_id);
+                    yp_node_t *result = (yp_node_t *) yp_local_variable_and_write_node_create(parser, node, &token, value, cast->constant_id, cast->depth);
 
                     yp_node_destroy(parser, node);
                     return result;
                 }
+                case YP_NODE_CALL_NODE: {
+                    yp_call_node_t *call_node = (yp_call_node_t *) node;
+
+                    // If we have a vcall (a method with no arguments and no
+                    // receiver that could have been a local variable) then we
+                    // will transform it into a local variable write.
+                    if (yp_call_node_variable_call_p(call_node)) {
+                        yp_location_t message_loc = call_node->message_loc;
+                        yp_constant_id_t constant_id = yp_parser_local_add_location(parser, message_loc.start, message_loc.end);
+
+                        if (token_is_numbered_parameter(message_loc.start, message_loc.end)) {
+                            yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter");
+                        }
+
+                        parser_lex(parser);
+                        yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
+                        yp_node_t *result = (yp_node_t *) yp_local_variable_and_write_node_create(parser, node, &token, value, constant_id, 0);
+
+                        yp_node_destroy(parser, node);
+                        return result;
+                    }
+
+                    parser_lex(parser);
+                    node = parse_target(parser, node);
+
+                    yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
+                    return (yp_node_t *) yp_call_operator_and_write_node_create(parser, (yp_call_node_t *) node, &token, value);
+                }
                 case YP_NODE_MULTI_WRITE_NODE: {
                     parser_lex(parser);
                     yp_diagnostic_list_append(&parser->error_list, token.start, token.end, "Cannot use `&&=' on a multi-write.");
@@ -12503,48 +12851,16 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
-                    yp_node_t *result = (yp_node_t *) yp_global_variable_operator_or_write_node_create(parser, node, &token, value);
+                    yp_node_t *result = (yp_node_t *) yp_global_variable_or_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
                 }
-                case YP_NODE_CALL_NODE: {
-                    yp_call_node_t *call_node = (yp_call_node_t *) node;
-
-                    // If we have a vcall (a method with no arguments and no
-                    // receiver that could have been a local variable) then we
-                    // will transform it into a local variable write.
-                    if (yp_call_node_variable_call_p(call_node)) {
-                        yp_location_t message_loc = call_node->message_loc;
-                        yp_parser_local_add_location(parser, message_loc.start, message_loc.end);
-
-                        if (token_is_numbered_parameter(message_loc.start, message_loc.end)) {
-                            yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter");
-                        }
-
-                        parser_lex(parser);
-
-                        yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
-                        yp_constant_id_t constant_id = yp_parser_constant_id_location(parser, message_loc.start, message_loc.end);
-                        yp_node_t *result = (yp_node_t *) yp_local_variable_operator_or_write_node_create(parser, node, &token, value, constant_id);
-
-                        yp_node_destroy(parser, node);
-                        return result;
-                    }
-
-                    parser_lex(parser);
-
-                    yp_token_t operator = not_provided(parser);
-                    node = parse_target(parser, node, &operator, NULL);
-
-                    yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
-                    return (yp_node_t *) yp_call_operator_or_write_node_create(parser, (yp_call_node_t *) node, &token, value);
-                }
                 case YP_NODE_CLASS_VARIABLE_READ_NODE: {
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
-                    yp_node_t *result = (yp_node_t *) yp_class_variable_operator_or_write_node_create(parser, node, &token, value);
+                    yp_node_t *result = (yp_node_t *) yp_class_variable_or_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
@@ -12553,13 +12869,13 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
-                    return (yp_node_t *) yp_constant_path_operator_or_write_node_create(parser, (yp_constant_path_node_t *) node, &token, value);
+                    return (yp_node_t *) yp_constant_path_or_write_node_create(parser, (yp_constant_path_node_t *) node, &token, value);
                 }
                 case YP_NODE_CONSTANT_READ_NODE: {
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
-                    yp_node_t *result = (yp_node_t *) yp_constant_operator_or_write_node_create(parser, node, &token, value);
+                    yp_node_t *result = (yp_node_t *) yp_constant_or_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
@@ -12568,21 +12884,49 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
-                    yp_node_t *result = (yp_node_t *) yp_instance_variable_operator_or_write_node_create(parser, node, &token, value);
+                    yp_node_t *result = (yp_node_t *) yp_instance_variable_or_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
                 }
                 case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
+                    yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node;
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
-                    yp_constant_id_t constant_id = ((yp_local_variable_read_node_t *) node)->constant_id;
-                    yp_node_t *result = (yp_node_t *) yp_local_variable_operator_or_write_node_create(parser, node, &token, value, constant_id);
+                    yp_node_t *result = (yp_node_t *) yp_local_variable_or_write_node_create(parser, node, &token, value, cast->constant_id, cast->depth);
 
                     yp_node_destroy(parser, node);
                     return result;
                 }
+                case YP_NODE_CALL_NODE: {
+                    yp_call_node_t *call_node = (yp_call_node_t *) node;
+
+                    // If we have a vcall (a method with no arguments and no
+                    // receiver that could have been a local variable) then we
+                    // will transform it into a local variable write.
+                    if (yp_call_node_variable_call_p(call_node)) {
+                        yp_location_t message_loc = call_node->message_loc;
+                        yp_constant_id_t constant_id = yp_parser_local_add_location(parser, message_loc.start, message_loc.end);
+
+                        if (token_is_numbered_parameter(message_loc.start, message_loc.end)) {
+                            yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter");
+                        }
+
+                        parser_lex(parser);
+                        yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
+                        yp_node_t *result = (yp_node_t *) yp_local_variable_or_write_node_create(parser, node, &token, value, constant_id, 0);
+
+                        yp_node_destroy(parser, node);
+                        return result;
+                    }
+
+                    parser_lex(parser);
+                    node = parse_target(parser, node);
+
+                    yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
+                    return (yp_node_t *) yp_call_operator_or_write_node_create(parser, (yp_call_node_t *) node, &token, value);
+                }
                 case YP_NODE_MULTI_WRITE_NODE: {
                     parser_lex(parser);
                     yp_diagnostic_list_append(&parser->error_list, token.start, token.end, "Cannot use `||=' on a multi-write.");
@@ -12617,43 +12961,12 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                 case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
                     parser_lex(parser);
 
-                    yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator");
+                    yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator.");
                     yp_node_t *result = (yp_node_t *) yp_global_variable_operator_write_node_create(parser, node, &token, value);
 
                     yp_node_destroy(parser, node);
                     return result;
                 }
-                case YP_NODE_CALL_NODE: {
-                    yp_call_node_t *call_node = (yp_call_node_t *) node;
-
-                    // If we have a vcall (a method with no arguments and no
-                    // receiver that could have been a local variable) then we
-                    // will transform it into a local variable write.
-                    if (yp_call_node_variable_call_p(call_node)) {
-                        yp_location_t message_loc = call_node->message_loc;
-                        yp_parser_local_add_location(parser, message_loc.start, message_loc.end);
-
-                        if (token_is_numbered_parameter(message_loc.start, message_loc.end)) {
-                            yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter");
-                        }
-
-                        parser_lex(parser);
-
-                        yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
-                        yp_constant_id_t constant_id = yp_parser_constant_id_location(parser, message_loc.start, message_loc.end);
-                        yp_node_t *result = (yp_node_t *) yp_local_variable_operator_write_node_create(parser, node, &token, value, constant_id);
-
-                        yp_node_destroy(parser, node);
-                        return result;
-                    }
-
-                    yp_token_t operator = not_provided(parser);
-                    node = parse_target(parser, node, &operator, NULL);
-
-                    parser_lex(parser);
-                    yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator.");
-                    return (yp_node_t *) yp_call_operator_write_node_create(parser, (yp_call_node_t *) node, &token, value);
-                }
                 case YP_NODE_CLASS_VARIABLE_READ_NODE: {
                     parser_lex(parser);
 
@@ -12688,15 +13001,43 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
                     return result;
                 }
                 case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
+                    yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node;
                     parser_lex(parser);
 
                     yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator.");
-                    yp_constant_id_t constant_id = ((yp_local_variable_read_node_t *) node)->constant_id;
-                    yp_node_t *result = (yp_node_t *) yp_local_variable_operator_write_node_create(parser, node, &token, value, constant_id);
+                    yp_node_t *result = (yp_node_t *) yp_local_variable_operator_write_node_create(parser, node, &token, value, cast->constant_id, cast->depth);
 
                     yp_node_destroy(parser, node);
                     return result;
                 }
+                case YP_NODE_CALL_NODE: {
+                    yp_call_node_t *call_node = (yp_call_node_t *) node;
+
+                    // If we have a vcall (a method with no arguments and no
+                    // receiver that could have been a local variable) then we
+                    // will transform it into a local variable write.
+                    if (yp_call_node_variable_call_p(call_node)) {
+                        yp_location_t message_loc = call_node->message_loc;
+                        yp_constant_id_t constant_id = yp_parser_local_add_location(parser, message_loc.start, message_loc.end);
+
+                        if (token_is_numbered_parameter(message_loc.start, message_loc.end)) {
+                            yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter");
+                        }
+
+                        parser_lex(parser);
+                        yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator.");
+                        yp_node_t *result = (yp_node_t *) yp_local_variable_operator_write_node_create(parser, node, &token, value, constant_id, 0);
+
+                        yp_node_destroy(parser, node);
+                        return result;
+                    }
+
+                    node = parse_target(parser, node);
+                    parser_lex(parser);
+
+                    yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator.");
+                    return (yp_node_t *) yp_call_operator_write_node_create(parser, (yp_call_node_t *) node, &token, value);
+                }
                 case YP_NODE_MULTI_WRITE_NODE: {
                     parser_lex(parser);
                     yp_diagnostic_list_append(&parser->error_list, token.start, token.end, "Unexpected operator.");
@@ -12862,7 +13203,7 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
             yp_statements_node_body_append(statements, node);
 
             yp_node_t *predicate = parse_expression(parser, binding_power, "Expected a predicate after 'until'");
-            return (yp_node_t *) yp_until_node_create(parser, &token, predicate, statements, YP_NODE_TYPE_P(node, YP_NODE_BEGIN_NODE) ? YP_LOOP_FLAGS_BEGIN_MODIFIER : 0);
+            return (yp_node_t *) yp_until_node_modifier_create(parser, &token, predicate, statements, YP_NODE_TYPE_P(node, YP_NODE_BEGIN_NODE) ? YP_LOOP_FLAGS_BEGIN_MODIFIER : 0);
         }
         case YP_TOKEN_KEYWORD_WHILE_MODIFIER: {
             parser_lex(parser);
@@ -12870,7 +13211,7 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
             yp_statements_node_body_append(statements, node);
 
             yp_node_t *predicate = parse_expression(parser, binding_power, "Expected a predicate after 'while'");
-            return (yp_node_t *) yp_while_node_create(parser, &token, predicate, statements, YP_NODE_TYPE_P(node, YP_NODE_BEGIN_NODE) ? YP_LOOP_FLAGS_BEGIN_MODIFIER : 0);
+            return (yp_node_t *) yp_while_node_modifier_create(parser, &token, predicate, statements, YP_NODE_TYPE_P(node, YP_NODE_BEGIN_NODE) ? YP_LOOP_FLAGS_BEGIN_MODIFIER : 0);
         }
         case YP_TOKEN_QUESTION_MARK: {
             parser_lex(parser);
@@ -12908,7 +13249,7 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
 
                     if (
                         (parser->current.type == YP_TOKEN_PARENTHESIS_LEFT) ||
-                        (token_begins_expression_p(parser->current.type) || match_any_type_p(parser, 2, YP_TOKEN_USTAR, YP_TOKEN_USTAR_STAR))
+                        (token_begins_expression_p(parser->current.type) || match_any_type_p(parser, 3, YP_TOKEN_UAMPERSAND, YP_TOKEN_USTAR, YP_TOKEN_USTAR_STAR))
                     ) {
                         // If we have a constant immediately following a '::' operator, then
                         // this can either be a constant path or a method call, depending on
@@ -13140,7 +13481,7 @@ yp_metadata_read_u32(const char *ptr) {
 //   ]*
 // ]
 // ```
-static void
+void
 yp_parser_metadata(yp_parser_t *parser, const char *metadata) {
     uint32_t filepath_size = yp_metadata_read_u32(metadata);
     metadata += 4;
@@ -13179,6 +13520,8 @@ yp_parser_metadata(yp_parser_t *parser, const char *metadata) {
 // Initialize a parser with the given start and end pointers.
 YP_EXPORTED_FUNCTION void
 yp_parser_init(yp_parser_t *parser, const char *source, size_t size, const char *filepath) {
+    assert(source != NULL);
+
     // Set filepath to the file that was passed
     if (!filepath) filepath = "";
     yp_string_t filepath_string;
@@ -13190,6 +13533,8 @@ yp_parser_init(yp_parser_t *parser, const char *source, size_t size, const char
         .enclosure_nesting = 0,
         .lambda_enclosure_nesting = -1,
         .brace_nesting = 0,
+        .do_loop_stack = YP_STATE_STACK_EMPTY,
+        .accepts_block_stack = YP_STATE_STACK_EMPTY,
         .lex_modes = {
             .index = 0,
             .stack = {{ .mode = YP_LEX_DEFAULT }},
@@ -13201,6 +13546,9 @@ yp_parser_init(yp_parser_t *parser, const char *source, size_t size, const char
         .current = { .type = YP_TOKEN_EOF, .start = source, .end = source },
         .next_start = NULL,
         .heredoc_end = NULL,
+        .comment_list = YP_LIST_EMPTY,
+        .warning_list = YP_LIST_EMPTY,
+        .error_list = YP_LIST_EMPTY,
         .current_scope = NULL,
         .current_context = NULL,
         .recovering = false,
@@ -13213,16 +13561,12 @@ yp_parser_init(yp_parser_t *parser, const char *source, size_t size, const char
         .pattern_matching_newlines = false,
         .in_keyword_arg = false,
         .filepath_string = filepath_string,
+        .constant_pool = YP_CONSTANT_POOL_EMPTY,
+        .newline_list = YP_NEWLINE_LIST_EMPTY
     };
 
-    yp_state_stack_init(&parser->do_loop_stack);
-    yp_state_stack_init(&parser->accepts_block_stack);
     yp_accepts_block_stack_push(parser, true);
 
-    yp_list_init(&parser->warning_list);
-    yp_list_init(&parser->error_list);
-    yp_list_init(&parser->comment_list);
-
     // Initialize the constant pool. We're going to completely guess as to the
     // number of constants that we'll need based on the size of the input. The
     // ratio we chose here is actually less arbitrary than you might think.
@@ -13246,14 +13590,15 @@ yp_parser_init(yp_parser_t *parser, const char *source, size_t size, const char
     size_t newline_size = size / 22;
     yp_newline_list_init(&parser->newline_list, source, newline_size < 4 ? 4 : newline_size);
 
-    assert(source != NULL);
+    // Skip past the UTF-8 BOM if it exists.
     if (size >= 3 && (unsigned char) source[0] == 0xef && (unsigned char) source[1] == 0xbb && (unsigned char) source[2] == 0xbf) {
-        // If the first three bytes of the source are the UTF-8 BOM, then we'll skip
-        // over them.
         parser->current.end += 3;
-    } else if (size >= 2 && source[0] == '#' && source[1] == '!') {
-        // If the first two bytes of the source are a shebang, then we'll indicate
-        // that the encoding comment is at the end of the shebang.
+        parser->encoding_comment_start += 3;
+    }
+
+    // If the first two bytes of the source are a shebang, then we'll indicate
+    // that the encoding comment is at the end of the shebang.
+    if (peek(parser) == '#' && peek_offset(parser, 1) == '!') {
         const char *encoding_comment_start = next_newline(source, (ptrdiff_t) size);
         if (encoding_comment_start) {
             parser->encoding_comment_start = encoding_comment_start + 1;