prism 0.18.0 → 0.19.0

data/src/prettyprint.c

@@ -251,16 +251,30 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " contains_keyword_splat", 23);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // arguments
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 arguments:", 20);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 arguments:", 20);
                 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->arguments.size));
 
                 size_t last_index = cast->arguments.size;
                 for (uint32_t index = 0; index < last_index; index++) {
                     size_t prefix_length = prefix_buffer->length;
-                    pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                    pm_buffer_append_string(prefix_buffer, "    ", 4);
                     pm_buffer_concat(output_buffer, prefix_buffer);
 
                     if (index == last_index - 1) {
@@ -276,28 +290,28 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
+            break;
+        }
+        case PM_ARRAY_NODE: {
+            pm_array_node_t *cast = (pm_array_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ ArrayNode (location: ", 23);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
             // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
                 bool found = false;
-                if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_KEYWORD_SPLAT) {
+                if (cast->base.flags & PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " keyword_splat", 14);
+                    pm_buffer_append_string(output_buffer, " contains_splat", 15);
                     found = true;
                 }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
 
-            break;
-        }
-        case PM_ARRAY_NODE: {
-            pm_array_node_t *cast = (pm_array_node_t *) node;
-            pm_buffer_append_string(output_buffer, "@ ArrayNode (location: ", 23);
-            prettyprint_location(output_buffer, parser, &node->location);
-            pm_buffer_append_string(output_buffer, ")\n", 2);
-
             // elements
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -769,6 +783,13 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "]\n", 2);
             }
 
+            // locals_body_index
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 locals_body_index:", 28);
+                pm_buffer_append_format(output_buffer, " %d\n", cast->locals_body_index);
+            }
+
             // parameters
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1003,6 +1024,30 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " variable_call", 14);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // receiver
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1052,25 +1097,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
-                    found = true;
-                }
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " variable_call", 14);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             // read_name
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1122,6 +1148,30 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " variable_call", 14);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // receiver
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1155,6 +1205,15 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
+            // name
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 name:", 15);
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_constant(output_buffer, parser, cast->name);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // message_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1223,20 +1282,28 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             // block
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 block:", 16);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 block:", 16);
                 if (cast->block == NULL) {
                     pm_buffer_append_string(output_buffer, " \xe2\x88\x85\n", 5);
                 } else {
                     pm_buffer_append_byte(output_buffer, '\n');
 
                     size_t prefix_length = prefix_buffer->length;
-                    pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                    pm_buffer_append_string(prefix_buffer, "    ", 4);
                     pm_buffer_concat(output_buffer, prefix_buffer);
                     prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
                     prefix_buffer->length = prefix_length;
                 }
             }
 
+            break;
+        }
+        case PM_CALL_OPERATOR_WRITE_NODE: {
+            pm_call_operator_write_node_t *cast = (pm_call_operator_write_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ CallOperatorWriteNode (location: ", 35);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
             // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1252,27 +1319,15 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " variable_call", 14);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
 
-            // name
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 name:", 15);
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_constant(output_buffer, parser, cast->name);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
-            break;
-        }
-        case PM_CALL_OPERATOR_WRITE_NODE: {
-            pm_call_operator_write_node_t *cast = (pm_call_operator_write_node_t *) node;
-            pm_buffer_append_string(output_buffer, "@ CallOperatorWriteNode (location: ", 35);
-            prettyprint_location(output_buffer, parser, &node->location);
-            pm_buffer_append_string(output_buffer, ")\n", 2);
-
             // receiver
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1322,25 +1377,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
-                    found = true;
-                }
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " variable_call", 14);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             // read_name
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1401,6 +1437,30 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " variable_call", 14);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // receiver
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1450,25 +1510,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
-                    found = true;
-                }
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " variable_call", 14);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             // read_name
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -1514,43 +1555,54 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
 
             break;
         }
-        case PM_CAPTURE_PATTERN_NODE: {
-            pm_capture_pattern_node_t *cast = (pm_capture_pattern_node_t *) node;
-            pm_buffer_append_string(output_buffer, "@ CapturePatternNode (location: ", 32);
+        case PM_CALL_TARGET_NODE: {
+            pm_call_target_node_t *cast = (pm_call_target_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ CallTargetNode (location: ", 28);
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
-            // value
+            // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 value:", 16);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " variable_call", 14);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
-
-                size_t prefix_length = prefix_buffer->length;
-                pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
-                prefix_buffer->length = prefix_length;
             }
 
-            // target
+            // receiver
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 target:", 17);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 receiver:", 19);
                 pm_buffer_append_byte(output_buffer, '\n');
 
                 size_t prefix_length = prefix_buffer->length;
                 pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                prettyprint_node(output_buffer, parser, (pm_node_t *) cast->target, prefix_buffer);
+                prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
                 prefix_buffer->length = prefix_length;
             }
 
-            // operator_loc
+            // call_operator_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 operator_loc:", 23);
-                pm_location_t *location = &cast->operator_loc;
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 call_operator_loc:", 28);
+                pm_location_t *location = &cast->call_operator_loc;
                 pm_buffer_append_byte(output_buffer, ' ');
                 prettyprint_location(output_buffer, parser, location);
                 pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -1558,22 +1610,89 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "\"\n", 2);
             }
 
-            break;
-        }
-        case PM_CASE_MATCH_NODE: {
-            pm_case_match_node_t *cast = (pm_case_match_node_t *) node;
-            pm_buffer_append_string(output_buffer, "@ CaseMatchNode (location: ", 27);
-            prettyprint_location(output_buffer, parser, &node->location);
-            pm_buffer_append_string(output_buffer, ")\n", 2);
-
-            // predicate
+            // name
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 predicate:", 20);
-                if (cast->predicate == NULL) {
-                    pm_buffer_append_string(output_buffer, " \xe2\x88\x85\n", 5);
-                } else {
-                    pm_buffer_append_byte(output_buffer, '\n');
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 name:", 15);
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_constant(output_buffer, parser, cast->name);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
+            // message_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 message_loc:", 22);
+                pm_location_t *location = &cast->message_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            break;
+        }
+        case PM_CAPTURE_PATTERN_NODE: {
+            pm_capture_pattern_node_t *cast = (pm_capture_pattern_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ CapturePatternNode (location: ", 32);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
+            // value
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 value:", 16);
+                pm_buffer_append_byte(output_buffer, '\n');
+
+                size_t prefix_length = prefix_buffer->length;
+                pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
+                prefix_buffer->length = prefix_length;
+            }
+
+            // target
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 target:", 17);
+                pm_buffer_append_byte(output_buffer, '\n');
+
+                size_t prefix_length = prefix_buffer->length;
+                pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                prettyprint_node(output_buffer, parser, (pm_node_t *) cast->target, prefix_buffer);
+                prefix_buffer->length = prefix_length;
+            }
+
+            // operator_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 operator_loc:", 23);
+                pm_location_t *location = &cast->operator_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            break;
+        }
+        case PM_CASE_MATCH_NODE: {
+            pm_case_match_node_t *cast = (pm_case_match_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ CaseMatchNode (location: ", 27);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
+            // predicate
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 predicate:", 20);
+                if (cast->predicate == NULL) {
+                    pm_buffer_append_string(output_buffer, " \xe2\x88\x85\n", 5);
+                } else {
+                    pm_buffer_append_byte(output_buffer, '\n');
 
                     size_t prefix_length = prefix_buffer->length;
                     pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
@@ -2763,6 +2882,13 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "]\n", 2);
             }
 
+            // locals_body_index
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 locals_body_index:", 28);
+                pm_buffer_append_format(output_buffer, " %d\n", cast->locals_body_index);
+            }
+
             // def_keyword_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -3227,6 +3353,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_RANGE_FLAGS_EXCLUDE_END) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " exclude_end", 12);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // left
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -3264,7 +3404,7 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             // operator_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 operator_loc:", 23);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 operator_loc:", 23);
                 pm_location_t *location = &cast->operator_loc;
                 pm_buffer_append_byte(output_buffer, ' ');
                 prettyprint_location(output_buffer, parser, location);
@@ -3273,20 +3413,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "\"\n", 2);
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_RANGE_FLAGS_EXCLUDE_END) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " exclude_end", 12);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             break;
         }
         case PM_FLOAT_NODE: {
@@ -3998,6 +4124,13 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
 
             break;
         }
+        case PM_IMPLICIT_REST_NODE: {
+            pm_buffer_append_string(output_buffer, "@ ImplicitRestNode (location: ", 30);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
+            break;
+        }
         case PM_IN_NODE: {
             pm_in_node_t *cast = (pm_in_node_t *) node;
             pm_buffer_append_string(output_buffer, "@ InNode (location: ", 20);
@@ -4070,6 +4203,30 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " variable_call", 14);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // receiver
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -4161,25 +4318,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
-                    found = true;
-                }
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " variable_call", 14);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             // operator_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -4213,6 +4351,30 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " variable_call", 14);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // receiver
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -4304,25 +4466,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
-                    found = true;
-                }
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " variable_call", 14);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             // operator
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -4365,6 +4508,30 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " variable_call", 14);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // receiver
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -4456,25 +4623,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
-                    found = true;
-                }
-                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " variable_call", 14);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             // operator_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -4502,25 +4650,128 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
 
             break;
         }
-        case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
-            pm_instance_variable_and_write_node_t *cast = (pm_instance_variable_and_write_node_t *) node;
-            pm_buffer_append_string(output_buffer, "@ InstanceVariableAndWriteNode (location: ", 42);
+        case PM_INDEX_TARGET_NODE: {
+            pm_index_target_node_t *cast = (pm_index_target_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ IndexTargetNode (location: ", 29);
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
-            // name
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 name:", 15);
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_constant(output_buffer, parser, cast->name);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
-            // name_loc
+            // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 name_loc:", 19);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " safe_navigation", 16);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " variable_call", 14);
+                    found = true;
+                }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " attribute_write", 16);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
+            // receiver
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 receiver:", 19);
+                pm_buffer_append_byte(output_buffer, '\n');
+
+                size_t prefix_length = prefix_buffer->length;
+                pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
+                prefix_buffer->length = prefix_length;
+            }
+
+            // opening_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 opening_loc:", 22);
+                pm_location_t *location = &cast->opening_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // arguments
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 arguments:", 20);
+                if (cast->arguments == NULL) {
+                    pm_buffer_append_string(output_buffer, " \xe2\x88\x85\n", 5);
+                } else {
+                    pm_buffer_append_byte(output_buffer, '\n');
+
+                    size_t prefix_length = prefix_buffer->length;
+                    pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                    pm_buffer_concat(output_buffer, prefix_buffer);
+                    prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
+                    prefix_buffer->length = prefix_length;
+                }
+            }
+
+            // closing_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
+                pm_location_t *location = &cast->closing_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // block
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 block:", 16);
+                if (cast->block == NULL) {
+                    pm_buffer_append_string(output_buffer, " \xe2\x88\x85\n", 5);
+                } else {
+                    pm_buffer_append_byte(output_buffer, '\n');
+
+                    size_t prefix_length = prefix_buffer->length;
+                    pm_buffer_append_string(prefix_buffer, "    ", 4);
+                    pm_buffer_concat(output_buffer, prefix_buffer);
+                    prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
+                    prefix_buffer->length = prefix_length;
+                }
+            }
+
+            break;
+        }
+        case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
+            pm_instance_variable_and_write_node_t *cast = (pm_instance_variable_and_write_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ InstanceVariableAndWriteNode (location: ", 42);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
+            // name
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 name:", 15);
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_constant(output_buffer, parser, cast->name);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
+            // name_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 name_loc:", 19);
                 pm_location_t *location = &cast->name_loc;
                 pm_buffer_append_byte(output_buffer, ' ');
                 prettyprint_location(output_buffer, parser, location);
@@ -4777,14 +5028,14 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " binary", 7);
                     found = true;
                 }
-                if (cast->base.flags & PM_INTEGER_BASE_FLAGS_OCTAL) {
+                if (cast->base.flags & PM_INTEGER_BASE_FLAGS_DECIMAL) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " octal", 6);
+                    pm_buffer_append_string(output_buffer, " decimal", 8);
                     found = true;
                 }
-                if (cast->base.flags & PM_INTEGER_BASE_FLAGS_DECIMAL) {
+                if (cast->base.flags & PM_INTEGER_BASE_FLAGS_OCTAL) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " decimal", 8);
+                    pm_buffer_append_string(output_buffer, " octal", 6);
                     found = true;
                 }
                 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_HEXADECIMAL) {
@@ -4804,59 +5055,10 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
-            // opening_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 opening_loc:", 22);
-                pm_location_t *location = &cast->opening_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
-            // parts
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 parts:", 16);
-                pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->parts.size));
-
-                size_t last_index = cast->parts.size;
-                for (uint32_t index = 0; index < last_index; index++) {
-                    size_t prefix_length = prefix_buffer->length;
-                    pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
-                    pm_buffer_concat(output_buffer, prefix_buffer);
-
-                    if (index == last_index - 1) {
-                        pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 ", 10);
-                        pm_buffer_append_string(prefix_buffer, "    ", 4);
-                    } else {
-                        pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 ", 10);
-                        pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
-                    }
-
-                    prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parts.nodes[index], prefix_buffer);
-                    prefix_buffer->length = prefix_length;
-                }
-            }
-
-            // closing_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
-                pm_location_t *location = &cast->closing_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
             // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
                 bool found = false;
                 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
@@ -4898,18 +5100,25 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " utf_8", 6);
                     found = true;
                 }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
+                    found = true;
+                }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
+                    found = true;
+                }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
 
-            break;
-        }
-        case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
-            pm_interpolated_regular_expression_node_t *cast = (pm_interpolated_regular_expression_node_t *) node;
-            pm_buffer_append_string(output_buffer, "@ InterpolatedRegularExpressionNode (location: ", 47);
-            prettyprint_location(output_buffer, parser, &node->location);
-            pm_buffer_append_string(output_buffer, ")\n", 2);
-
             // opening_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -4950,7 +5159,7 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             // closing_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
                 pm_location_t *location = &cast->closing_loc;
                 pm_buffer_append_byte(output_buffer, ' ');
                 prettyprint_location(output_buffer, parser, location);
@@ -4959,10 +5168,18 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "\"\n", 2);
             }
 
+            break;
+        }
+        case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
+            pm_interpolated_regular_expression_node_t *cast = (pm_interpolated_regular_expression_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ InterpolatedRegularExpressionNode (location: ", 47);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
             // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
                 bool found = false;
                 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
@@ -5004,10 +5221,74 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " utf_8", 6);
                     found = true;
                 }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
+                    found = true;
+                }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
+                    found = true;
+                }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
 
+            // opening_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 opening_loc:", 22);
+                pm_location_t *location = &cast->opening_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // parts
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 parts:", 16);
+                pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->parts.size));
+
+                size_t last_index = cast->parts.size;
+                for (uint32_t index = 0; index < last_index; index++) {
+                    size_t prefix_length = prefix_buffer->length;
+                    pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                    pm_buffer_concat(output_buffer, prefix_buffer);
+
+                    if (index == last_index - 1) {
+                        pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 ", 10);
+                        pm_buffer_append_string(prefix_buffer, "    ", 4);
+                    } else {
+                        pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 ", 10);
+                        pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                    }
+
+                    prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parts.nodes[index], prefix_buffer);
+                    prefix_buffer->length = prefix_length;
+                }
+            }
+
+            // closing_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
+                pm_location_t *location = &cast->closing_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
             break;
         }
         case PM_INTERPOLATED_STRING_NODE: {
@@ -5203,6 +5484,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_KEYWORD_HASH_NODE_FLAGS_STATIC_KEYS) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " static_keys", 12);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // elements
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -5297,6 +5592,13 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "]\n", 2);
             }
 
+            // locals_body_index
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 locals_body_index:", 28);
+                pm_buffer_append_format(output_buffer, " %d\n", cast->locals_body_index);
+            }
+
             // operator_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -5676,55 +5978,10 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
-            // opening_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 opening_loc:", 22);
-                pm_location_t *location = &cast->opening_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
-            // content_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 content_loc:", 22);
-                pm_location_t *location = &cast->content_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
-            // closing_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
-                pm_location_t *location = &cast->closing_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
-            // unescaped
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 unescaped:", 20);
-                pm_buffer_append_string(output_buffer, " \"", 2);
-                prettyprint_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
             // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
                 bool found = false;
                 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
@@ -5766,10 +6023,70 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " utf_8", 6);
                     found = true;
                 }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
+                    found = true;
+                }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
+                    found = true;
+                }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
 
+            // opening_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 opening_loc:", 22);
+                pm_location_t *location = &cast->opening_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // content_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 content_loc:", 22);
+                pm_location_t *location = &cast->content_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // closing_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
+                pm_location_t *location = &cast->closing_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // unescaped
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 unescaped:", 20);
+                pm_buffer_append_string(output_buffer, " \"", 2);
+                prettyprint_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
             break;
         }
         case PM_MATCH_PREDICATE_NODE: {
@@ -6315,6 +6632,21 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
 
             break;
         }
+        case PM_NUMBERED_PARAMETERS_NODE: {
+            pm_numbered_parameters_node_t *cast = (pm_numbered_parameters_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ NumberedParametersNode (location: ", 36);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
+            // maximum
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 maximum:", 18);
+                pm_buffer_append_format(output_buffer, " %d\n", cast->maximum);
+            }
+
+            break;
+        }
         case PM_NUMBERED_REFERENCE_READ_NODE: {
             pm_numbered_reference_read_node_t *cast = (pm_numbered_reference_read_node_t *) node;
             pm_buffer_append_string(output_buffer, "@ NumberedReferenceReadNode (location: ", 39);
@@ -6931,6 +7263,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_RANGE_FLAGS_EXCLUDE_END) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " exclude_end", 12);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // left
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -6968,7 +7314,7 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             // operator_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 operator_loc:", 23);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 operator_loc:", 23);
                 pm_location_t *location = &cast->operator_loc;
                 pm_buffer_append_byte(output_buffer, ' ');
                 prettyprint_location(output_buffer, parser, location);
@@ -6977,20 +7323,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "\"\n", 2);
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_RANGE_FLAGS_EXCLUDE_END) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " exclude_end", 12);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             break;
         }
         case PM_RATIONAL_NODE: {
@@ -7027,55 +7359,10 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
-            // opening_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 opening_loc:", 22);
-                pm_location_t *location = &cast->opening_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
-            // content_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 content_loc:", 22);
-                pm_location_t *location = &cast->content_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
-            // closing_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
-                pm_location_t *location = &cast->closing_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
-            // unescaped
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 unescaped:", 20);
-                pm_buffer_append_string(output_buffer, " \"", 2);
-                prettyprint_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
             // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
                 bool found = false;
                 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
@@ -7117,10 +7404,70 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " utf_8", 6);
                     found = true;
                 }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
+                    found = true;
+                }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
+                    found = true;
+                }
+                if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
 
+            // opening_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 opening_loc:", 22);
+                pm_location_t *location = &cast->opening_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // content_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 content_loc:", 22);
+                pm_location_t *location = &cast->content_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // closing_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 closing_loc:", 22);
+                pm_location_t *location = &cast->closing_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // unescaped
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 unescaped:", 20);
+                pm_buffer_append_string(output_buffer, " \"", 2);
+                prettyprint_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
             break;
         }
         case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
@@ -7625,6 +7972,16 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_concat(output_buffer, prefix_buffer);
                 pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
                 bool found = false;
+                if (cast->base.flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
+                    found = true;
+                }
+                if (cast->base.flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
+                    found = true;
+                }
                 if (cast->base.flags & PM_STRING_FLAGS_FROZEN) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
                     pm_buffer_append_string(output_buffer, " frozen", 7);
@@ -7781,6 +8138,30 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
+                    found = true;
+                }
+                if (cast->base.flags & PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
+                    found = true;
+                }
+                if (cast->base.flags & PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // opening_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -7997,6 +8378,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " begin_modifier", 15);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // keyword_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -8041,34 +8436,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             // statements
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 statements:", 21);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 statements:", 21);
                 if (cast->statements == NULL) {
                     pm_buffer_append_string(output_buffer, " \xe2\x88\x85\n", 5);
                 } else {
                     pm_buffer_append_byte(output_buffer, '\n');
 
                     size_t prefix_length = prefix_buffer->length;
-                    pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                    pm_buffer_append_string(prefix_buffer, "    ", 4);
                     pm_buffer_concat(output_buffer, prefix_buffer);
                     prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
                     prefix_buffer->length = prefix_length;
                 }
             }
 
-            // flags
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
-                bool found = false;
-                if (cast->base.flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
-                    if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " begin_modifier", 15);
-                    found = true;
-                }
-                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
             break;
         }
         case PM_WHEN_NODE: {
@@ -8139,6 +8520,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             prettyprint_location(output_buffer, parser, &node->location);
             pm_buffer_append_string(output_buffer, ")\n", 2);
 
+            // flags
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                bool found = false;
+                if (cast->base.flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " begin_modifier", 15);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // keyword_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
@@ -8183,42 +8578,47 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
             // statements
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 statements:", 21);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 statements:", 21);
                 if (cast->statements == NULL) {
                     pm_buffer_append_string(output_buffer, " \xe2\x88\x85\n", 5);
                 } else {
                     pm_buffer_append_byte(output_buffer, '\n');
 
                     size_t prefix_length = prefix_buffer->length;
-                    pm_buffer_append_string(prefix_buffer, "\xe2\x94\x82   ", 6);
+                    pm_buffer_append_string(prefix_buffer, "    ", 4);
                     pm_buffer_concat(output_buffer, prefix_buffer);
                     prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
                     prefix_buffer->length = prefix_length;
                 }
             }
 
+            break;
+        }
+        case PM_X_STRING_NODE: {
+            pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ XStringNode (location: ", 25);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
             // flags
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 flags:", 16);
+                pm_buffer_append_string(output_buffer, "\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 flags:", 16);
                 bool found = false;
-                if (cast->base.flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
+                if (cast->base.flags & PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " begin_modifier", 15);
+                    pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
+                    found = true;
+                }
+                if (cast->base.flags & PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
                     found = true;
                 }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
 
-            break;
-        }
-        case PM_X_STRING_NODE: {
-            pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
-            pm_buffer_append_string(output_buffer, "@ XStringNode (location: ", 25);
-            prettyprint_location(output_buffer, parser, &node->location);
-            pm_buffer_append_string(output_buffer, ")\n", 2);
-
             // opening_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);