prism 0.26.0 → 0.28.0

data/src/diagnostic.c

@@ -8,7 +8,7 @@
 
 #include "prism/diagnostic.h"
 
-#define PM_DIAGNOSTIC_ID_MAX 281
+#define PM_DIAGNOSTIC_ID_MAX 291
 
 /** This struct holds the data for each diagnostic. */
 typedef struct {
@@ -166,12 +166,12 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_END_UPCASE_TERM]                    = { "expected a `}` to close the `END` statement", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_CONTROL]             = { "invalid control escape sequence", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT]      = { "invalid control escape sequence; control cannot be repeated", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ESCAPE_INVALID_HEXADECIMAL]         = { "invalid hexadecimal escape sequence", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ESCAPE_INVALID_HEXADECIMAL]         = { "invalid hex escape sequence", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_META]                = { "invalid meta escape sequence", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_META_REPEAT]         = { "invalid meta escape sequence; meta cannot be repeated", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE]             = { "invalid Unicode escape sequence", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_CM_FLAGS]    = { "invalid Unicode escape sequence; Unicode cannot be combined with control or meta flags", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL]     = { "invalid Unicode escape sequence; multiple codepoints are not allowed in a character literal", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL]     = { "invalid Unicode escape sequence; Multiple codepoints at single character literal are disallowed", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_LONG]        = { "invalid Unicode escape sequence; maximum length is 6 digits", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_TERM]        = { "invalid Unicode escape sequence; needs closing `}`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_ARGUMENT]                    = { "expected an argument", PM_ERROR_LEVEL_SYNTAX },
@@ -215,20 +215,24 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_HASH_ROCKET]                        = { "expected a `=>` between the hash key and value", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_HASH_TERM]                          = { "expected a `}` to close the hash literal", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_HASH_VALUE]                         = { "expected a value in the hash literal", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_HEREDOC_TERM]                       = { "could not find a terminator for the heredoc", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_HEREDOC_IDENTIFIER]                 = { "unterminated here document identifier", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_HEREDOC_TERM]                       = { "unterminated heredoc; can't find string \"%.*s\"", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INCOMPLETE_QUESTION_MARK]           = { "incomplete expression at `?`", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3_0]    = { "`%.*s' is not allowed as a class variable name", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3]      = { "`%.*s' is not allowed as a class variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INCOMPLETE_VARIABLE_CLASS]          = { "'%.*s' is not allowed as a class variable name", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3_0] = { "`%.*s' is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3]   = { "`%.*s' is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INCOMPLETE_VARIABLE_INSTANCE]       = { "'%.*s' is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INSTANCE_VARIABLE_BARE]             = { "'@' without identifiers is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_BLOCK_EXIT]                 = { "Invalid %s", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_FLOAT_EXPONENT]             = { "invalid exponent", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_NUMBER_BINARY]              = { "invalid binary number", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_NUMBER_DECIMAL]             = { "invalid decimal number", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_NUMBER_HEXADECIMAL]         = { "invalid hexadecimal number", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_NUMBER_OCTAL]               = { "invalid octal number", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_NUMBER_UNDERSCORE]          = { "invalid underscore placement in number", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_LOCAL_VARIABLE_READ]        = { "identifier %.*s is not valid to get", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_LOCAL_VARIABLE_WRITE]       = { "identifier %.*s is not valid to set", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_NUMBER_BINARY]              = { "invalid binary number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_NUMBER_DECIMAL]             = { "invalid decimal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_NUMBER_HEXADECIMAL]         = { "invalid hexadecimal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_NUMBER_OCTAL]               = { "invalid octal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER]    = { "invalid underscore placement in number", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING] = { "trailing '_' in number", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_CHARACTER]                  = { "invalid character 0x%X", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_CHAR]             = { "invalid multibyte char (%s)", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_CHARACTER]        = { "invalid multibyte character 0x%X", PM_ERROR_LEVEL_SYNTAX },
@@ -238,7 +242,8 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_INVALID_RETRY_AFTER_ELSE]           = { "Invalid retry after else", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_AFTER_ENSURE]         = { "Invalid retry after ensure", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_WITHOUT_RESCUE]       = { "Invalid retry without rescue", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_VARIABLE_GLOBAL_3_3_0]      = { "`%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_SYMBOL]                     = { "invalid symbol", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_VARIABLE_GLOBAL_3_3]        = { "`%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_VARIABLE_GLOBAL]            = { "'%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_YIELD]                      = { "Invalid yield", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_IT_NOT_ALLOWED_NUMBERED]            = { "`it` is not allowed when an numbered parameter is defined", PM_ERROR_LEVEL_SYNTAX },
@@ -247,13 +252,13 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_LAMBDA_TERM_BRACE]                  = { "expected a lambda block beginning with `{` to end with `}`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LAMBDA_TERM_END]                    = { "expected a lambda block beginning with `do` to end with `end`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LIST_I_LOWER_ELEMENT]               = { "expected a symbol in a `%i` list", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_LIST_I_LOWER_TERM]                  = { "expected a closing delimiter for the `%i` list", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_LIST_I_LOWER_TERM]                  = { "unterminated list; expected a closing delimiter for the `%i`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LIST_I_UPPER_ELEMENT]               = { "expected a symbol in a `%I` list", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_LIST_I_UPPER_TERM]                  = { "expected a closing delimiter for the `%I` list", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_LIST_I_UPPER_TERM]                  = { "unterminated list; expected a closing delimiter for the `%I`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LIST_W_LOWER_ELEMENT]               = { "expected a string in a `%w` list", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_LIST_W_LOWER_TERM]                  = { "expected a closing delimiter for the `%w` list", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_LIST_W_LOWER_TERM]                  = { "unterminated list; expected a closing delimiter for the `%w`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LIST_W_UPPER_ELEMENT]               = { "expected a string in a `%W` list", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_LIST_W_UPPER_TERM]                  = { "expected a closing delimiter for the `%W` list", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_LIST_W_UPPER_TERM]                  = { "unterminated list; expected a closing delimiter for the `%W`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_MALLOC_FAILED]                      = { "failed to allocate memory", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_MIXED_ENCODING]                     = { "UTF-8 mixed within %s source", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_MODULE_IN_METHOD]                   = { "unexpected module definition in method body", PM_ERROR_LEVEL_SYNTAX },
@@ -283,6 +288,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_PARAMETER_STAR]                     = { "unexpected parameter `*`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PARAMETER_UNEXPECTED_FWD]           = { "unexpected `...` in parameters", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PARAMETER_WILD_LOOSE_COMMA]         = { "unexpected `,` in parameters", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_PARAMETER_UNEXPECTED_NO_KW]         = { "unexpected **nil; no keywords marker disallowed after keywords", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_CAPTURE_DUPLICATE]          = { "duplicated variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET]   = { "expected a pattern expression after the `[` operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA]     = { "expected a pattern expression after `,`", PM_ERROR_LEVEL_SYNTAX },
@@ -297,6 +303,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_PATTERN_HASH_KEY]                   = { "expected a key in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_HASH_KEY_DUPLICATE]         = { "duplicated key name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_HASH_KEY_LABEL]             = { "expected a label as the key in the hash pattern", PM_ERROR_LEVEL_SYNTAX }, // TODO // THIS // AND // ABOVE // IS WEIRD
+    [PM_ERR_PATTERN_HASH_KEY_LOCALS]            = { "key must be valid as local variables", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_IDENT_AFTER_HROCKET]        = { "expected an identifier after the `=>` operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_LABEL_AFTER_COMMA]          = { "expected a label after the `,` in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_REST]                       = { "unexpected rest pattern", PM_ERROR_LEVEL_SYNTAX },
@@ -309,7 +316,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_REGEXP_NON_ESCAPED_MBC]             = { "/.../n has a non escaped non ASCII character in non ASCII-8BIT script: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_REGEXP_INVALID_UNICODE_RANGE]       = { "invalid Unicode range: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_REGEXP_UNKNOWN_OPTIONS]             = { "unknown regexp %s: %.*s", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_REGEXP_TERM]                        = { "expected a closing delimiter for the regular expression", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_REGEXP_TERM]                        = { "unterminated regexp meets end of file; expected a closing delimiter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_REGEXP_UTF8_CHAR_NON_UTF8_REGEXP]   = { "UTF-8 character in non UTF-8 regexp: /%s/", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_RESCUE_EXPRESSION]                  = { "expected a rescued expression", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_RESCUE_MODIFIER_VALUE]              = { "expected a value after the `rescue` modifier", PM_ERROR_LEVEL_SYNTAX },
@@ -326,7 +333,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_STRING_LITERAL_EOF]                 = { "unterminated string meets end of file", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STRING_LITERAL_TERM]                = { "unexpected %s, expected a string literal terminator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_SYMBOL_INVALID]                     = { "invalid symbol", PM_ERROR_LEVEL_SYNTAX }, // TODO expected symbol? prism.c ~9719
-    [PM_ERR_SYMBOL_TERM_DYNAMIC]                = { "expected a closing delimiter for the dynamic symbol", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_SYMBOL_TERM_DYNAMIC]                = { "unterminated quoted string; expected a closing delimiter for the dynamic symbol", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_SYMBOL_TERM_INTERPOLATED]           = { "expected a closing delimiter for the interpolated symbol", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_TERNARY_COLON]                      = { "expected a `:` after the true expression of a ternary operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_TERNARY_EXPRESSION_FALSE]           = { "expected an expression after `:` in the ternary operator", PM_ERROR_LEVEL_SYNTAX },
@@ -334,6 +341,9 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_UNDEF_ARGUMENT]                     = { "invalid argument being passed to `undef`; expected a bare word, constant, or symbol argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNARY_RECEIVER]                     = { "unexpected %s, expected a receiver for unary `%c`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_BLOCK_ARGUMENT]          = { "block argument should not be given", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_UNEXPECTED_INDEX_BLOCK]             = { "unexpected block arg given in index; blocks are not allowed in index expressions", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_UNEXPECTED_INDEX_KEYWORDS]          = { "unexpected keyword arg given in index; keywords are not allowed in index expressions", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_UNEXPECTED_SAFE_NAVIGATION]         = { "&. inside multiple assignment destination", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT]     = { "unexpected %s, assuming it is closing the parent %s", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_TOKEN_IGNORE]            = { "unexpected %s, ignoring it", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNTIL_TERM]                         = { "expected an `end` to close the `until` statement", PM_ERROR_LEVEL_SYNTAX },
@@ -355,7 +365,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_WARN_DOT_DOT_DOT_EOL]                   = { "... at EOL, should be parenthesized?", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_DUPLICATED_HASH_KEY]               = { "key %.*s is duplicated and overwritten on line %" PRIi32, PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_DUPLICATED_WHEN_CLAUSE]            = { "duplicated 'when' clause with line %" PRIi32 " is ignored", PM_WARNING_LEVEL_VERBOSE },
-    [PM_WARN_EQUAL_IN_CONDITIONAL_3_3_0]        = { "found `= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
+    [PM_WARN_EQUAL_IN_CONDITIONAL_3_3]          = { "found `= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_EQUAL_IN_CONDITIONAL]              = { "found '= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_END_IN_METHOD]                     = { "END in method; use at_exit", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_FLOAT_OUT_OF_RANGE]                = { "Float %.*s%s out of range", PM_WARNING_LEVEL_VERBOSE },
@@ -504,17 +514,20 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_HASH_ROCKET: return "hash_rocket";
         case PM_ERR_HASH_TERM: return "hash_term";
         case PM_ERR_HASH_VALUE: return "hash_value";
+        case PM_ERR_HEREDOC_IDENTIFIER: return "heredoc_identifier";
         case PM_ERR_HEREDOC_TERM: return "heredoc_term";
         case PM_ERR_INCOMPLETE_QUESTION_MARK: return "incomplete_question_mark";
         case PM_ERR_INCOMPLETE_VARIABLE_CLASS: return "incomplete_variable_class";
-        case PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3_0: return "incomplete_variable_class_3_3_0";
+        case PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3: return "incomplete_variable_class_3_3";
         case PM_ERR_INCOMPLETE_VARIABLE_INSTANCE: return "incomplete_variable_instance";
-        case PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3_0: return "incomplete_variable_instance_3_3_0";
+        case PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3: return "incomplete_variable_instance_3_3";
         case PM_ERR_INSTANCE_VARIABLE_BARE: return "instance_variable_bare";
         case PM_ERR_INVALID_BLOCK_EXIT: return "invalid_block_exit";
         case PM_ERR_INVALID_CHARACTER: return "invalid_character";
         case PM_ERR_INVALID_ENCODING_MAGIC_COMMENT: return "invalid_encoding_magic_comment";
         case PM_ERR_INVALID_FLOAT_EXPONENT: return "invalid_float_exponent";
+        case PM_ERR_INVALID_LOCAL_VARIABLE_READ: return "invalid_local_variable_read";
+        case PM_ERR_INVALID_LOCAL_VARIABLE_WRITE: return "invalid_local_variable_write";
         case PM_ERR_INVALID_MULTIBYTE_CHAR: return "invalid_multibyte_char";
         case PM_ERR_INVALID_MULTIBYTE_CHARACTER: return "invalid_multibyte_character";
         case PM_ERR_INVALID_MULTIBYTE_ESCAPE: return "invalid_multibyte_escape";
@@ -522,14 +535,16 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_INVALID_NUMBER_DECIMAL: return "invalid_number_decimal";
         case PM_ERR_INVALID_NUMBER_HEXADECIMAL: return "invalid_number_hexadecimal";
         case PM_ERR_INVALID_NUMBER_OCTAL: return "invalid_number_octal";
-        case PM_ERR_INVALID_NUMBER_UNDERSCORE: return "invalid_number_underscore";
+        case PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER: return "invalid_number_underscore_inner";
+        case PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING: return "invalid_number_underscore_trailing";
         case PM_ERR_INVALID_PERCENT: return "invalid_percent";
         case PM_ERR_INVALID_PRINTABLE_CHARACTER: return "invalid_printable_character";
         case PM_ERR_INVALID_RETRY_AFTER_ELSE: return "invalid_retry_after_else";
         case PM_ERR_INVALID_RETRY_AFTER_ENSURE: return "invalid_retry_after_ensure";
         case PM_ERR_INVALID_RETRY_WITHOUT_RESCUE: return "invalid_retry_without_rescue";
+        case PM_ERR_INVALID_SYMBOL: return "invalid_symbol";
         case PM_ERR_INVALID_VARIABLE_GLOBAL: return "invalid_variable_global";
-        case PM_ERR_INVALID_VARIABLE_GLOBAL_3_3_0: return "invalid_variable_global_3_3_0";
+        case PM_ERR_INVALID_VARIABLE_GLOBAL_3_3: return "invalid_variable_global_3_3";
         case PM_ERR_INVALID_YIELD: return "invalid_yield";
         case PM_ERR_IT_NOT_ALLOWED_NUMBERED: return "it_not_allowed_numbered";
         case PM_ERR_IT_NOT_ALLOWED_ORDINARY: return "it_not_allowed_ordinary";
@@ -573,6 +588,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_PARAMETER_STAR: return "parameter_star";
         case PM_ERR_PARAMETER_UNEXPECTED_FWD: return "parameter_unexpected_fwd";
         case PM_ERR_PARAMETER_WILD_LOOSE_COMMA: return "parameter_wild_loose_comma";
+        case PM_ERR_PARAMETER_UNEXPECTED_NO_KW: return "parameter_unexpected_no_kw";
         case PM_ERR_PATTERN_CAPTURE_DUPLICATE: return "pattern_capture_duplicate";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET: return "pattern_expression_after_bracket";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA: return "pattern_expression_after_comma";
@@ -587,6 +603,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_PATTERN_HASH_KEY: return "pattern_hash_key";
         case PM_ERR_PATTERN_HASH_KEY_DUPLICATE: return "pattern_hash_key_duplicate";
         case PM_ERR_PATTERN_HASH_KEY_LABEL: return "pattern_hash_key_label";
+        case PM_ERR_PATTERN_HASH_KEY_LOCALS: return "pattern_hash_key_locals";
         case PM_ERR_PATTERN_IDENT_AFTER_HROCKET: return "pattern_ident_after_hrocket";
         case PM_ERR_PATTERN_LABEL_AFTER_COMMA: return "pattern_label_after_comma";
         case PM_ERR_PATTERN_REST: return "pattern_rest";
@@ -625,6 +642,9 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_UNARY_RECEIVER: return "unary_receiver";
         case PM_ERR_UNDEF_ARGUMENT: return "undef_argument";
         case PM_ERR_UNEXPECTED_BLOCK_ARGUMENT: return "unexpected_block_argument";
+        case PM_ERR_UNEXPECTED_INDEX_BLOCK: return "unexpected_index_block";
+        case PM_ERR_UNEXPECTED_INDEX_KEYWORDS: return "unexpected_index_keywords";
+        case PM_ERR_UNEXPECTED_SAFE_NAVIGATION: return "unexpected_safe_navigation";
         case PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT: return "unexpected_token_close_context";
         case PM_ERR_UNEXPECTED_TOKEN_IGNORE: return "unexpected_token_ignore";
         case PM_ERR_UNTIL_TERM: return "until_term";
@@ -643,7 +663,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_WARN_COMPARISON_AFTER_COMPARISON: return "comparison_after_comparison";
         case PM_WARN_DOT_DOT_DOT_EOL: return "dot_dot_dot_eol";
         case PM_WARN_EQUAL_IN_CONDITIONAL: return "equal_in_conditional";
-        case PM_WARN_EQUAL_IN_CONDITIONAL_3_3_0: return "equal_in_conditional_3_3_0";
+        case PM_WARN_EQUAL_IN_CONDITIONAL_3_3: return "equal_in_conditional_3_3";
         case PM_WARN_END_IN_METHOD: return "end_in_method";
         case PM_WARN_DUPLICATED_HASH_KEY: return "duplicated_hash_key";
         case PM_WARN_DUPLICATED_WHEN_CLAUSE: return "duplicated_when_clause";

data/src/node.c

@@ -414,7 +414,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
             if (cast->parent != NULL) {
                 pm_node_destroy(parser, (pm_node_t *)cast->parent);
             }
-            pm_node_destroy(parser, (pm_node_t *)cast->child);
             break;
         }
 #line 123 "node.c.erb"
@@ -437,7 +436,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
             if (cast->parent != NULL) {
                 pm_node_destroy(parser, (pm_node_t *)cast->parent);
             }
-            pm_node_destroy(parser, (pm_node_t *)cast->child);
             break;
         }
 #line 123 "node.c.erb"
@@ -1558,7 +1556,6 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
             if (cast->parent != NULL) {
                 pm_node_memsize_node((pm_node_t *)cast->parent, memsize);
             }
-            pm_node_memsize_node((pm_node_t *)cast->child, memsize);
             break;
         }
 #line 170 "node.c.erb"
@@ -1584,7 +1581,6 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
             if (cast->parent != NULL) {
                 pm_node_memsize_node((pm_node_t *)cast->parent, memsize);
             }
-            pm_node_memsize_node((pm_node_t *)cast->child, memsize);
             break;
         }
 #line 170 "node.c.erb"
@@ -3255,9 +3251,6 @@ pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *nod
                 pm_visit_node((const pm_node_t *) cast->parent, visitor, data);
             }
 
-            // Visit the child field
-            pm_visit_node((const pm_node_t *) cast->child, visitor, data);
-
             break;
         }
         case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
@@ -3290,9 +3283,6 @@ pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *nod
                 pm_visit_node((const pm_node_t *) cast->parent, visitor, data);
             }
 
-            // Visit the child field
-            pm_visit_node((const pm_node_t *) cast->child, visitor, data);
-
             break;
         }
         case PM_CONSTANT_PATH_WRITE_NODE: {
@@ -4434,6 +4424,11 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"flags\":", 8);
             size_t flags = 0;
             pm_buffer_append_byte(buffer, '[');
+            if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS)) {
+                if (flags != 0) pm_buffer_append_byte(buffer, ',');
+                pm_buffer_append_string(buffer, "\"CONTAINS_KEYWORDS\"", 19);
+                flags++;
+            }
             if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT)) {
                 if (flags != 0) pm_buffer_append_byte(buffer, ',');
                 pm_buffer_append_string(buffer, "\"CONTAINS_KEYWORD_SPLAT\"", 24);
@@ -5801,16 +5796,25 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
                 pm_buffer_append_string(buffer, "null", 4);
             }
 
-            // Dump the child field
+            // Dump the name field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"child\":", 8);
-            pm_dump_json(buffer, parser, (const pm_node_t *) cast->child);
+            pm_buffer_append_string(buffer, "\"name\":", 7);
+            if (cast->name != PM_CONSTANT_ID_UNSET) {
+                pm_dump_json_constant(buffer, parser, cast->name);
+            } else {
+                pm_buffer_append_string(buffer, "null", 4);
+            }
 
             // Dump the delimiter_loc field
             pm_buffer_append_byte(buffer, ',');
             pm_buffer_append_string(buffer, "\"delimiter_loc\":", 16);
             pm_dump_json_location(buffer, parser, &cast->delimiter_loc);
 
+            // Dump the name_loc field
+            pm_buffer_append_byte(buffer, ',');
+            pm_buffer_append_string(buffer, "\"name_loc\":", 11);
+            pm_dump_json_location(buffer, parser, &cast->name_loc);
+
             pm_buffer_append_byte(buffer, '}');
             break;
         }
@@ -5882,16 +5886,25 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
                 pm_buffer_append_string(buffer, "null", 4);
             }
 
-            // Dump the child field
+            // Dump the name field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"child\":", 8);
-            pm_dump_json(buffer, parser, (const pm_node_t *) cast->child);
+            pm_buffer_append_string(buffer, "\"name\":", 7);
+            if (cast->name != PM_CONSTANT_ID_UNSET) {
+                pm_dump_json_constant(buffer, parser, cast->name);
+            } else {
+                pm_buffer_append_string(buffer, "null", 4);
+            }
 
             // Dump the delimiter_loc field
             pm_buffer_append_byte(buffer, ',');
             pm_buffer_append_string(buffer, "\"delimiter_loc\":", 16);
             pm_dump_json_location(buffer, parser, &cast->delimiter_loc);
 
+            // Dump the name_loc field
+            pm_buffer_append_byte(buffer, ',');
+            pm_buffer_append_string(buffer, "\"name_loc\":", 11);
+            pm_dump_json_location(buffer, parser, &cast->name_loc);
+
             pm_buffer_append_byte(buffer, '}');
             break;
         }
@@ -9134,6 +9147,18 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             const pm_return_node_t *cast = (const pm_return_node_t *) node;
             pm_dump_json_location(buffer, parser, &cast->base.location);
 
+            // Dump the flags field
+            pm_buffer_append_byte(buffer, ',');
+            pm_buffer_append_string(buffer, "\"flags\":", 8);
+            size_t flags = 0;
+            pm_buffer_append_byte(buffer, '[');
+            if (PM_NODE_FLAG_P(cast, PM_RETURN_NODE_FLAGS_REDUNDANT)) {
+                if (flags != 0) pm_buffer_append_byte(buffer, ',');
+                pm_buffer_append_string(buffer, "\"REDUNDANT\"", 11);
+                flags++;
+            }
+            pm_buffer_append_byte(buffer, ']');
+
             // Dump the keyword_loc field
             pm_buffer_append_byte(buffer, ',');
             pm_buffer_append_string(buffer, "\"keyword_loc\":", 14);

data/src/options.c

@@ -58,8 +58,8 @@ pm_options_version_set(pm_options_t *options, const char *version, size_t length
         case 5:
             assert(version != NULL);
 
-            if (strncmp(version, "3.3.0", length) == 0) {
-                options->version = PM_OPTIONS_VERSION_CRUBY_3_3_0;
+            if ((strncmp(version, "3.3.0", length) == 0) || (strncmp(version, "3.3.1", length) == 0)) {
+                options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
                 return true;
             }
 

data/src/prettyprint.c

@@ -231,6 +231,11 @@ 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, "+-- flags:", 10);
                 bool found = false;
+                if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " contains_keywords", 18);
+                    found = true;
+                }
                 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);
@@ -2444,17 +2449,17 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
-            // child
+            // name
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "+-- child:", 10);
-                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->child, prefix_buffer);
-                prefix_buffer->length = prefix_length;
+                pm_buffer_append_string(output_buffer, "+-- name:", 9);
+                if (cast->name == 0) {
+                    pm_buffer_append_string(output_buffer, " nil\n", 5);
+                } else {
+                    pm_buffer_append_byte(output_buffer, ' ');
+                    prettyprint_constant(output_buffer, parser, cast->name);
+                    pm_buffer_append_byte(output_buffer, '\n');
+                }
             }
 
             // delimiter_loc
@@ -2469,6 +2474,18 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "\"\n", 2);
             }
 
+            // name_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
+                pm_location_t *location = &cast->name_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                pm_buffer_append_source(output_buffer, location->start, (size_t) (location->end - location->start), PM_BUFFER_ESCAPING_RUBY);
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
             break;
         }
         case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
@@ -2595,17 +2612,17 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 }
             }
 
-            // child
+            // name
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "+-- child:", 10);
-                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->child, prefix_buffer);
-                prefix_buffer->length = prefix_length;
+                pm_buffer_append_string(output_buffer, "+-- name:", 9);
+                if (cast->name == 0) {
+                    pm_buffer_append_string(output_buffer, " nil\n", 5);
+                } else {
+                    pm_buffer_append_byte(output_buffer, ' ');
+                    prettyprint_constant(output_buffer, parser, cast->name);
+                    pm_buffer_append_byte(output_buffer, '\n');
+                }
             }
 
             // delimiter_loc
@@ -2620,6 +2637,18 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
                 pm_buffer_append_string(output_buffer, "\"\n", 2);
             }
 
+            // name_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
+                pm_location_t *location = &cast->name_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                pm_buffer_append_source(output_buffer, location->start, (size_t) (location->end - location->start), PM_BUFFER_ESCAPING_RUBY);
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
             break;
         }
         case PM_CONSTANT_PATH_WRITE_NODE: {
@@ -7701,6 +7730,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, "+-- flags:", 10);
+                bool found = false;
+                if (cast->base.flags & PM_RETURN_NODE_FLAGS_REDUNDANT) {
+                    if (found) pm_buffer_append_byte(output_buffer, ',');
+                    pm_buffer_append_string(output_buffer, " redundant", 10);
+                    found = true;
+                }
+                if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
             // keyword_loc
             {
                 pm_buffer_concat(output_buffer, prefix_buffer);