prism 0.19.0 → 0.24.0

data/src/encoding.c

@@ -2252,13 +2252,13 @@ static const uint8_t pm_utf_8_dfa[] = {
  */
 static pm_unicode_codepoint_t
 pm_utf_8_codepoint(const uint8_t *b, ptrdiff_t n, size_t *width) {
-    assert(n >= 1);
-    size_t maximum = (size_t) n;
+    assert(n >= 0);
 
+    size_t maximum = (n > 4) ? 4 : ((size_t) n);
     uint32_t codepoint;
     uint32_t state = 0;
 
-    for (size_t index = 0; index < 4 && index < maximum; index++) {
+    for (size_t index = 0; index < maximum; index++) {
         uint32_t byte = b[index];
         uint32_t type = pm_utf_8_dfa[byte];
 
@@ -2267,7 +2267,7 @@ pm_utf_8_codepoint(const uint8_t *b, ptrdiff_t n, size_t *width) {
             (0xffu >> type) & (byte);
 
         state = pm_utf_8_dfa[256 + (state * 16) + type];
-        if (!state) {
+        if (state == 0) {
             *width = index + 1;
             return (pm_unicode_codepoint_t) codepoint;
         }
@@ -2277,11 +2277,22 @@ pm_utf_8_codepoint(const uint8_t *b, ptrdiff_t n, size_t *width) {
     return 0;
 }
 
-static size_t
+/**
+ * Return the size of the next character in the UTF-8 encoding.
+ */
+size_t
 pm_encoding_utf_8_char_width(const uint8_t *b, ptrdiff_t n) {
-    size_t width;
-    pm_utf_8_codepoint(b, n, &width);
-    return width;
+    assert(n >= 0);
+
+    size_t maximum = (n > 4) ? 4 : ((size_t) n);
+    uint32_t state = 0;
+
+    for (size_t index = 0; index < maximum; index++) {
+        state = pm_utf_8_dfa[256 + (state * 16) + pm_utf_8_dfa[b[index]]];
+        if (state == 0) return index + 1;
+    }
+
+    return 0;
 }
 
 /**
@@ -4183,15 +4194,6 @@ pm_encoding_gbk_char_width(const uint8_t *b, ptrdiff_t n) {
     return 0;
 }
 
-/**
- * Returns the size of the next character in the KOI-8 encoding. This means
- * checking if it's a valid codepoint in KOI-8 and if it is returning 1.
- */
-static size_t
-pm_encoding_koi8_char_width(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {
-    return ((*b >= 0x20 && *b <= 0x7E) || (*b >= 0x80)) ? 1 : 0;
-}
-
 /**
  * Returns the size of the next character in the Shift_JIS encoding, or 0 if a
  * character cannot be decoded from the given bytes.
@@ -4649,7 +4651,7 @@ const pm_encoding_t pm_encodings[] = {
     },
     [PM_ENCODING_KOI8_R] = {
         .name = "KOI8-R",
-        .char_width = pm_encoding_koi8_char_width,
+        .char_width = pm_encoding_single_char_width,
         .alnum_char = pm_encoding_koi8_r_alnum_char,
         .alpha_char = pm_encoding_koi8_r_alpha_char,
         .isupper_char = pm_encoding_koi8_r_isupper_char,
@@ -4657,7 +4659,7 @@ const pm_encoding_t pm_encodings[] = {
     },
     [PM_ENCODING_KOI8_U] = {
         .name = "KOI8-U",
-        .char_width = pm_encoding_koi8_char_width,
+        .char_width = pm_encoding_single_char_width,
         .alnum_char = pm_encoding_koi8_u_alnum_char,
         .alpha_char = pm_encoding_koi8_u_alpha_char,
         .isupper_char = pm_encoding_koi8_u_isupper_char,
@@ -5022,10 +5024,6 @@ pm_encoding_find(const uint8_t *start, const uint8_t *end) {
                 ENCODING2("EUC-CN", "eucCN", PM_ENCODING_GB2312);
                 ENCODING2("EUC-TW", "eucTW", PM_ENCODING_EUC_TW);
                 ENCODING1("Emacs-Mule", PM_ENCODING_EMACS_MULE);
-                ENCODING1("external", PM_ENCODING_UTF_8);
-                break;
-            case 'F': case 'f':
-                ENCODING1("filesystem", PM_ENCODING_UTF_8);
                 break;
             case 'G': case 'g':
                 ENCODING1("GBK", PM_ENCODING_GBK);
@@ -5071,9 +5069,6 @@ pm_encoding_find(const uint8_t *start, const uint8_t *end) {
                 ENCODING1("KOI8-R", PM_ENCODING_KOI8_R);
                 ENCODING1("KOI8-U", PM_ENCODING_KOI8_U);
                 break;
-            case 'L': case 'l':
-                ENCODING1("locale", PM_ENCODING_UTF_8);
-                break;
             case 'M': case 'm':
                 ENCODING1("macCentEuro", PM_ENCODING_MAC_CENT_EURO);
                 ENCODING1("macCroatian", PM_ENCODING_MAC_CROATIAN);

data/src/node.c

@@ -117,9 +117,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
         case PM_ASSOC_NODE: {
             pm_assoc_node_t *cast = (pm_assoc_node_t *) node;
             pm_node_destroy(parser, (pm_node_t *)cast->key);
-            if (cast->value != NULL) {
-                pm_node_destroy(parser, (pm_node_t *)cast->value);
-            }
+            pm_node_destroy(parser, (pm_node_t *)cast->value);
             break;
         }
 #line 58 "node.c.erb"
@@ -1223,9 +1221,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
             pm_assoc_node_t *cast = (pm_assoc_node_t *) node;
             memsize->memsize += sizeof(*cast);
             pm_node_memsize_node((pm_node_t *)cast->key, memsize);
-            if (cast->value != NULL) {
-                pm_node_memsize_node((pm_node_t *)cast->value, memsize);
-            }
+            pm_node_memsize_node((pm_node_t *)cast->value, memsize);
             break;
         }
 #line 103 "node.c.erb"

data/src/options.c

@@ -33,11 +33,35 @@ pm_options_frozen_string_literal_set(pm_options_t *options, bool frozen_string_l
 }
 
 /**
- * Set the suppress warnings option on the given options struct.
+ * Set the version option on the given options struct by parsing the given
+ * string. If the string contains an invalid option, this returns false.
+ * Otherwise, it returns true.
  */
-PRISM_EXPORTED_FUNCTION void
-pm_options_suppress_warnings_set(pm_options_t *options, bool suppress_warnings) {
-    options->suppress_warnings = suppress_warnings;
+PRISM_EXPORTED_FUNCTION bool
+pm_options_version_set(pm_options_t *options, const char *version, size_t length) {
+    if (version == NULL && length == 0) {
+        options->version = PM_OPTIONS_VERSION_LATEST;
+        return true;
+    }
+
+    if (length == 5) {
+        if (strncmp(version, "3.3.0", length) == 0) {
+            options->version = PM_OPTIONS_VERSION_CRUBY_3_3_0;
+            return true;
+        }
+
+        if (strncmp(version, "3.4.0", length) == 0) {
+            options->version = PM_OPTIONS_VERSION_LATEST;
+            return true;
+        }
+    }
+
+    if (length == 6 && strncmp(version, "latest", length) == 0) {
+        options->version = PM_OPTIONS_VERSION_LATEST;
+        return true;
+    }
+
+    return false;
 }
 
 /**
@@ -162,7 +186,7 @@ pm_options_read(pm_options_t *options, const char *data) {
     }
 
     options->frozen_string_literal = *data++;
-    options->suppress_warnings = *data++;
+    options->version = (pm_options_version_t) *data++;
 
     uint32_t scopes_count = pm_options_read_u32(data);
     data += 4;

data/src/prettyprint.c

@@ -44,9 +44,9 @@ prettyprint_source(pm_buffer_t *output_buffer, const uint8_t *source, size_t len
 
 static inline void
 prettyprint_location(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_location_t *location) {
-    pm_line_column_t start = pm_newline_list_line_column(&parser->newline_list, location->start);
-    pm_line_column_t end = pm_newline_list_line_column(&parser->newline_list, location->end);
-    pm_buffer_append_format(output_buffer, "(%lu,%lu)-(%lu,%lu)", (unsigned long) (start.line + 1), (unsigned long) start.column, (unsigned long) (end.line + 1), (unsigned long) end.column);
+    pm_line_column_t start = pm_newline_list_line_column(&parser->newline_list, location->start, parser->start_line);
+    pm_line_column_t end = pm_newline_list_line_column(&parser->newline_list, location->end, parser->start_line);
+    pm_buffer_append_format(output_buffer, "(%" PRIi32 ",%" PRIu32 ")-(%" PRIi32 ",%" PRIu32 ")", start.line, start.column, end.line, end.column);
 }
 
 static inline void
@@ -518,17 +518,13 @@ 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 value:", 16);
-                if (cast->value == NULL) {
-                    pm_buffer_append_string(output_buffer, " \xe2\x88\x85\n", 5);
-                } else {
-                    pm_buffer_append_byte(output_buffer, '\n');
+                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;
-                }
+                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;
             }
 
             // operator_loc
@@ -754,6 +750,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_PARAMETER_FLAGS_REPEATED_PARAMETER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
+                    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);
@@ -783,13 +793,6 @@ 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);
@@ -856,6 +859,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_PARAMETER_FLAGS_REPEATED_PARAMETER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
+                    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);
@@ -1044,6 +1061,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -1168,6 +1190,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -1324,6 +1351,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -1457,6 +1489,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -1581,6 +1618,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -2882,13 +2924,6 @@ 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);
@@ -4223,6 +4258,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -4371,6 +4411,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -4528,6 +4573,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -4676,6 +4726,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                     pm_buffer_append_string(output_buffer, " attribute_write", 16);
                     found = true;
                 }
+                if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
+                    found = true;
+                }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
                 pm_buffer_append_byte(output_buffer, '\n');
             }
@@ -5489,9 +5544,9 @@ 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_KEYWORD_HASH_NODE_FLAGS_STATIC_KEYS) {
+                if (cast->base.flags & PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS) {
                     if (found) pm_buffer_append_byte(output_buffer, ',');
-                    pm_buffer_append_string(output_buffer, " static_keys", 12);
+                    pm_buffer_append_string(output_buffer, " symbol_keys", 12);
                     found = true;
                 }
                 if (!found) pm_buffer_append_string(output_buffer, " \xe2\x88\x85", 4);
@@ -5531,6 +5586,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_PARAMETER_FLAGS_REPEATED_PARAMETER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
+                    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);
@@ -5592,13 +5661,6 @@ 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);
@@ -5727,7 +5789,7 @@ 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\x94\xe2\x94\x80\xe2\x94\x80 depth:", 16);
-                pm_buffer_append_format(output_buffer, " %d\n", cast->depth);
+                pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
             }
 
             break;
@@ -5797,7 +5859,7 @@ 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\x94\xe2\x94\x80\xe2\x94\x80 depth:", 16);
-                pm_buffer_append_format(output_buffer, " %d\n", cast->depth);
+                pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
             }
 
             break;
@@ -5858,7 +5920,7 @@ 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\x94\xe2\x94\x80\xe2\x94\x80 depth:", 16);
-                pm_buffer_append_format(output_buffer, " %d\n", cast->depth);
+                pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
             }
 
             break;
@@ -5882,7 +5944,7 @@ 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\x94\xe2\x94\x80\xe2\x94\x80 depth:", 16);
-                pm_buffer_append_format(output_buffer, " %d\n", cast->depth);
+                pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
             }
 
             break;
@@ -5906,7 +5968,7 @@ 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\x94\xe2\x94\x80\xe2\x94\x80 depth:", 16);
-                pm_buffer_append_format(output_buffer, " %d\n", cast->depth);
+                pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
             }
 
             break;
@@ -5930,7 +5992,7 @@ 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 depth:", 16);
-                pm_buffer_append_format(output_buffer, " %d\n", cast->depth);
+                pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
             }
 
             // name_loc
@@ -6642,7 +6704,7 @@ 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\x94\xe2\x94\x80\xe2\x94\x80 maximum:", 18);
-                pm_buffer_append_format(output_buffer, " %d\n", cast->maximum);
+                pm_buffer_append_format(output_buffer, " %" PRIu8 "\n", cast->maximum);
             }
 
             break;
@@ -6657,7 +6719,7 @@ 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\x94\xe2\x94\x80\xe2\x94\x80 number:", 17);
-                pm_buffer_append_format(output_buffer, " %d\n", cast->number);
+                pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->number);
             }
 
             break;
@@ -6668,6 +6730,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_PARAMETER_FLAGS_REPEATED_PARAMETER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
+                    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);
@@ -6710,6 +6786,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_PARAMETER_FLAGS_REPEATED_PARAMETER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
+                    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);
@@ -7476,6 +7566,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_PARAMETER_FLAGS_REPEATED_PARAMETER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
+                    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);
@@ -7505,6 +7609,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_PARAMETER_FLAGS_REPEATED_PARAMETER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
+                    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);
@@ -7680,6 +7798,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_PARAMETER_FLAGS_REPEATED_PARAMETER) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
+                    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);