gettext_i18n_rails_js 2.2.0 → 2.2.2

data/vendor/bundle/ruby/3.4.0/gems/prism-1.5.2/config.yml

@@ -0,0 +1,4714 @@
+errors:
+  - ALIAS_ARGUMENT
+  - ALIAS_ARGUMENT_NUMBERED_REFERENCE
+  - AMPAMPEQ_MULTI_ASSIGN
+  - ARGUMENT_AFTER_BLOCK
+  - ARGUMENT_AFTER_FORWARDING_ELLIPSES
+  - ARGUMENT_BARE_HASH
+  - ARGUMENT_BLOCK_FORWARDING
+  - ARGUMENT_BLOCK_MULTI
+  - ARGUMENT_CONFLICT_AMPERSAND
+  - ARGUMENT_CONFLICT_STAR
+  - ARGUMENT_CONFLICT_STAR_STAR
+  - ARGUMENT_FORMAL_CLASS
+  - ARGUMENT_FORMAL_CONSTANT
+  - ARGUMENT_FORMAL_GLOBAL
+  - ARGUMENT_FORMAL_IVAR
+  - ARGUMENT_FORWARDING_UNBOUND
+  - ARGUMENT_NO_FORWARDING_AMPERSAND
+  - ARGUMENT_NO_FORWARDING_ELLIPSES
+  - ARGUMENT_NO_FORWARDING_STAR
+  - ARGUMENT_NO_FORWARDING_STAR_STAR
+  - ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT
+  - ARGUMENT_SPLAT_AFTER_SPLAT
+  - ARGUMENT_TERM_PAREN
+  - ARGUMENT_UNEXPECTED_BLOCK
+  - ARRAY_ELEMENT
+  - ARRAY_EXPRESSION
+  - ARRAY_EXPRESSION_AFTER_STAR
+  - ARRAY_SEPARATOR
+  - ARRAY_TERM
+  - BEGIN_LONELY_ELSE
+  - BEGIN_TERM
+  - BEGIN_UPCASE_BRACE
+  - BEGIN_UPCASE_TERM
+  - BEGIN_UPCASE_TOPLEVEL
+  - BLOCK_PARAM_LOCAL_VARIABLE
+  - BLOCK_PARAM_PIPE_TERM
+  - BLOCK_TERM_BRACE
+  - BLOCK_TERM_END
+  - CANNOT_PARSE_EXPRESSION
+  - CANNOT_PARSE_STRING_PART
+  - CASE_EXPRESSION_AFTER_CASE
+  - CASE_EXPRESSION_AFTER_WHEN
+  - CASE_MATCH_MISSING_PREDICATE
+  - CASE_MISSING_CONDITIONS
+  - CASE_TERM
+  - CLASS_IN_METHOD
+  - CLASS_NAME
+  - CLASS_SUPERCLASS
+  - CLASS_TERM
+  - CLASS_UNEXPECTED_END
+  - CLASS_VARIABLE_BARE
+  - CONDITIONAL_ELSIF_PREDICATE
+  - CONDITIONAL_IF_PREDICATE
+  - CONDITIONAL_PREDICATE_TERM
+  - CONDITIONAL_TERM
+  - CONDITIONAL_TERM_ELSE
+  - CONDITIONAL_UNLESS_PREDICATE
+  - CONDITIONAL_UNTIL_PREDICATE
+  - CONDITIONAL_WHILE_PREDICATE
+  - CONSTANT_PATH_COLON_COLON_CONSTANT
+  - DEF_ENDLESS
+  - DEF_ENDLESS_PARAMETERS
+  - DEF_ENDLESS_SETTER
+  - DEF_NAME
+  - DEF_PARAMS_TERM
+  - DEF_PARAMS_TERM_PAREN
+  - DEF_RECEIVER
+  - DEF_RECEIVER_TERM
+  - DEF_TERM
+  - DEFINED_EXPRESSION
+  - EMBDOC_TERM
+  - EMBEXPR_END
+  - EMBVAR_INVALID
+  - END_UPCASE_BRACE
+  - END_UPCASE_TERM
+  - ESCAPE_INVALID_CONTROL
+  - ESCAPE_INVALID_CONTROL_REPEAT
+  - ESCAPE_INVALID_HEXADECIMAL
+  - ESCAPE_INVALID_META
+  - ESCAPE_INVALID_META_REPEAT
+  - ESCAPE_INVALID_UNICODE
+  - ESCAPE_INVALID_UNICODE_CM_FLAGS
+  - ESCAPE_INVALID_UNICODE_LIST
+  - ESCAPE_INVALID_UNICODE_LITERAL
+  - ESCAPE_INVALID_UNICODE_LONG
+  - ESCAPE_INVALID_UNICODE_SHORT
+  - ESCAPE_INVALID_UNICODE_TERM
+  - EXPECT_ARGUMENT
+  - EXPECT_EOL_AFTER_STATEMENT
+  - EXPECT_EXPRESSION_AFTER_AMPAMPEQ
+  - EXPECT_EXPRESSION_AFTER_COMMA
+  - EXPECT_EXPRESSION_AFTER_EQUAL
+  - EXPECT_EXPRESSION_AFTER_LESS_LESS
+  - EXPECT_EXPRESSION_AFTER_LPAREN
+  - EXPECT_EXPRESSION_AFTER_OPERATOR
+  - EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ
+  - EXPECT_EXPRESSION_AFTER_QUESTION
+  - EXPECT_EXPRESSION_AFTER_SPLAT
+  - EXPECT_EXPRESSION_AFTER_SPLAT_HASH
+  - EXPECT_EXPRESSION_AFTER_STAR
+  - EXPECT_FOR_DELIMITER
+  - EXPECT_IDENT_REQ_PARAMETER
+  - EXPECT_IN_DELIMITER
+  - EXPECT_LPAREN_AFTER_NOT_LPAREN
+  - EXPECT_LPAREN_AFTER_NOT_OTHER
+  - EXPECT_LPAREN_REQ_PARAMETER
+  - EXPECT_MESSAGE
+  - EXPECT_RBRACKET
+  - EXPECT_RPAREN
+  - EXPECT_RPAREN_AFTER_MULTI
+  - EXPECT_RPAREN_REQ_PARAMETER
+  - EXPECT_SINGLETON_CLASS_DELIMITER
+  - EXPECT_STRING_CONTENT
+  - EXPECT_WHEN_DELIMITER
+  - EXPRESSION_BARE_HASH
+  - EXPRESSION_NOT_WRITABLE
+  - EXPRESSION_NOT_WRITABLE_ENCODING
+  - EXPRESSION_NOT_WRITABLE_FALSE
+  - EXPRESSION_NOT_WRITABLE_FILE
+  - EXPRESSION_NOT_WRITABLE_LINE
+  - EXPRESSION_NOT_WRITABLE_NIL
+  - EXPRESSION_NOT_WRITABLE_NUMBERED
+  - EXPRESSION_NOT_WRITABLE_SELF
+  - EXPRESSION_NOT_WRITABLE_TRUE
+  - FLOAT_PARSE
+  - FOR_COLLECTION
+  - FOR_IN
+  - FOR_INDEX
+  - FOR_TERM
+  - GLOBAL_VARIABLE_BARE
+  - HASH_EXPRESSION_AFTER_LABEL
+  - HASH_KEY
+  - HASH_ROCKET
+  - HASH_TERM
+  - HASH_VALUE
+  - HEREDOC_IDENTIFIER
+  - HEREDOC_TERM
+  - INCOMPLETE_QUESTION_MARK
+  - INCOMPLETE_VARIABLE_CLASS
+  - INCOMPLETE_VARIABLE_CLASS_3_3
+  - INCOMPLETE_VARIABLE_INSTANCE
+  - INCOMPLETE_VARIABLE_INSTANCE_3_3
+  - INSTANCE_VARIABLE_BARE
+  - INVALID_BLOCK_EXIT
+  - INVALID_CHARACTER
+  - INVALID_COMMA
+  - INVALID_ENCODING_MAGIC_COMMENT
+  - INVALID_ESCAPE_CHARACTER
+  - INVALID_FLOAT_EXPONENT
+  - INVALID_LOCAL_VARIABLE_READ
+  - INVALID_LOCAL_VARIABLE_WRITE
+  - INVALID_MULTIBYTE_CHAR
+  - INVALID_MULTIBYTE_CHARACTER
+  - INVALID_MULTIBYTE_ESCAPE
+  - INVALID_NUMBER_BINARY
+  - INVALID_NUMBER_DECIMAL
+  - INVALID_NUMBER_FRACTION
+  - INVALID_NUMBER_HEXADECIMAL
+  - INVALID_NUMBER_OCTAL
+  - INVALID_NUMBER_UNDERSCORE_INNER
+  - INVALID_NUMBER_UNDERSCORE_TRAILING
+  - INVALID_PERCENT
+  - INVALID_PERCENT_EOF
+  - INVALID_PRINTABLE_CHARACTER
+  - INVALID_RETRY_AFTER_ELSE
+  - INVALID_RETRY_AFTER_ENSURE
+  - INVALID_RETRY_WITHOUT_RESCUE
+  - INVALID_SYMBOL
+  - INVALID_VARIABLE_GLOBAL
+  - INVALID_VARIABLE_GLOBAL_3_3
+  - INVALID_YIELD
+  - IT_NOT_ALLOWED_NUMBERED
+  - IT_NOT_ALLOWED_ORDINARY
+  - LAMBDA_OPEN
+  - LAMBDA_TERM_BRACE
+  - LAMBDA_TERM_END
+  - LIST_I_LOWER_ELEMENT
+  - LIST_I_LOWER_TERM
+  - LIST_I_UPPER_ELEMENT
+  - LIST_I_UPPER_TERM
+  - LIST_W_LOWER_ELEMENT
+  - LIST_W_LOWER_TERM
+  - LIST_W_UPPER_ELEMENT
+  - LIST_W_UPPER_TERM
+  - MALLOC_FAILED
+  - MIXED_ENCODING
+  - MODULE_IN_METHOD
+  - MODULE_NAME
+  - MODULE_TERM
+  - MULTI_ASSIGN_MULTI_SPLATS
+  - MULTI_ASSIGN_UNEXPECTED_REST
+  - NESTING_TOO_DEEP
+  - NO_LOCAL_VARIABLE
+  - NON_ASSOCIATIVE_OPERATOR
+  - NOT_EXPRESSION
+  - NUMBER_LITERAL_UNDERSCORE
+  - NUMBERED_PARAMETER_INNER_BLOCK
+  - NUMBERED_PARAMETER_IT
+  - NUMBERED_PARAMETER_ORDINARY
+  - NUMBERED_PARAMETER_OUTER_BLOCK
+  - OPERATOR_MULTI_ASSIGN
+  - OPERATOR_WRITE_ARGUMENTS
+  - OPERATOR_WRITE_BLOCK
+  - PARAMETER_ASSOC_SPLAT_MULTI
+  - PARAMETER_BLOCK_MULTI
+  - PARAMETER_CIRCULAR
+  - PARAMETER_FORWARDING_AFTER_REST
+  - PARAMETER_METHOD_NAME
+  - PARAMETER_NAME_DUPLICATED
+  - PARAMETER_NO_DEFAULT
+  - PARAMETER_NO_DEFAULT_KW
+  - PARAMETER_NUMBERED_RESERVED
+  - PARAMETER_ORDER
+  - PARAMETER_SPLAT_MULTI
+  - PARAMETER_STAR
+  - PARAMETER_UNEXPECTED_FWD
+  - PARAMETER_UNEXPECTED_NO_KW
+  - PARAMETER_WILD_LOOSE_COMMA
+  - PATTERN_ARRAY_MULTIPLE_RESTS
+  - PATTERN_CAPTURE_DUPLICATE
+  - PATTERN_EXPRESSION_AFTER_BRACKET
+  - PATTERN_EXPRESSION_AFTER_COMMA
+  - PATTERN_EXPRESSION_AFTER_HROCKET
+  - PATTERN_EXPRESSION_AFTER_IN
+  - PATTERN_EXPRESSION_AFTER_KEY
+  - PATTERN_EXPRESSION_AFTER_PAREN
+  - PATTERN_EXPRESSION_AFTER_PIN
+  - PATTERN_EXPRESSION_AFTER_PIPE
+  - PATTERN_EXPRESSION_AFTER_RANGE
+  - PATTERN_EXPRESSION_AFTER_REST
+  - PATTERN_FIND_MISSING_INNER
+  - PATTERN_HASH_IMPLICIT
+  - PATTERN_HASH_KEY
+  - PATTERN_HASH_KEY_DUPLICATE
+  - PATTERN_HASH_KEY_INTERPOLATED
+  - PATTERN_HASH_KEY_LABEL
+  - PATTERN_HASH_KEY_LOCALS
+  - PATTERN_IDENT_AFTER_HROCKET
+  - PATTERN_LABEL_AFTER_COMMA
+  - PATTERN_REST
+  - PATTERN_TERM_BRACE
+  - PATTERN_TERM_BRACKET
+  - PATTERN_TERM_PAREN
+  - PIPEPIPEEQ_MULTI_ASSIGN
+  - REGEXP_ENCODING_OPTION_MISMATCH
+  - REGEXP_INCOMPAT_CHAR_ENCODING
+  - REGEXP_INVALID_UNICODE_RANGE
+  - REGEXP_NON_ESCAPED_MBC
+  - REGEXP_PARSE_ERROR
+  - REGEXP_TERM
+  - REGEXP_UNKNOWN_OPTIONS
+  - REGEXP_UTF8_CHAR_NON_UTF8_REGEXP
+  - RESCUE_EXPRESSION
+  - RESCUE_MODIFIER_VALUE
+  - RESCUE_TERM
+  - RESCUE_VARIABLE
+  - RETURN_INVALID
+  - SCRIPT_NOT_FOUND
+  - SINGLETON_FOR_LITERALS
+  - STATEMENT_ALIAS
+  - STATEMENT_POSTEXE_END
+  - STATEMENT_PREEXE_BEGIN
+  - STATEMENT_UNDEF
+  - STRING_CONCATENATION
+  - STRING_INTERPOLATED_TERM
+  - STRING_LITERAL_EOF
+  - STRING_LITERAL_TERM
+  - SYMBOL_INVALID
+  - SYMBOL_TERM_DYNAMIC
+  - SYMBOL_TERM_INTERPOLATED
+  - TERNARY_COLON
+  - TERNARY_EXPRESSION_FALSE
+  - TERNARY_EXPRESSION_TRUE
+  - UNARY_DISALLOWED
+  - UNARY_RECEIVER
+  - UNDEF_ARGUMENT
+  - UNEXPECTED_BLOCK_ARGUMENT
+  - UNEXPECTED_INDEX_BLOCK
+  - UNEXPECTED_INDEX_KEYWORDS
+  - UNEXPECTED_LABEL
+  - UNEXPECTED_MULTI_WRITE
+  - UNEXPECTED_RANGE_OPERATOR
+  - UNEXPECTED_SAFE_NAVIGATION
+  - UNEXPECTED_TOKEN_CLOSE_CONTEXT
+  - UNEXPECTED_TOKEN_IGNORE
+  - UNTIL_TERM
+  - VOID_EXPRESSION
+  - WHILE_TERM
+  - WRITE_TARGET_IN_METHOD
+  - WRITE_TARGET_READONLY
+  - WRITE_TARGET_UNEXPECTED
+  - XSTRING_TERM
+warnings:
+  - AMBIGUOUS_BINARY_OPERATOR
+  - AMBIGUOUS_FIRST_ARGUMENT_MINUS
+  - AMBIGUOUS_FIRST_ARGUMENT_PLUS
+  - AMBIGUOUS_PREFIX_AMPERSAND
+  - AMBIGUOUS_PREFIX_STAR
+  - AMBIGUOUS_PREFIX_STAR_STAR
+  - AMBIGUOUS_SLASH
+  - COMPARISON_AFTER_COMPARISON
+  - DOT_DOT_DOT_EOL
+  - EQUAL_IN_CONDITIONAL
+  - EQUAL_IN_CONDITIONAL_3_3
+  - END_IN_METHOD
+  - DUPLICATED_HASH_KEY
+  - DUPLICATED_WHEN_CLAUSE
+  - FLOAT_OUT_OF_RANGE
+  - IGNORED_FROZEN_STRING_LITERAL
+  - INDENTATION_MISMATCH
+  - INTEGER_IN_FLIP_FLOP
+  - INVALID_CHARACTER
+  - INVALID_MAGIC_COMMENT_VALUE
+  - INVALID_NUMBERED_REFERENCE
+  - KEYWORD_EOL
+  - LITERAL_IN_CONDITION_DEFAULT
+  - LITERAL_IN_CONDITION_VERBOSE
+  - SHAREABLE_CONSTANT_VALUE_LINE
+  - SHEBANG_CARRIAGE_RETURN
+  - UNEXPECTED_CARRIAGE_RETURN
+  - UNREACHABLE_STATEMENT
+  - UNUSED_LOCAL_VARIABLE
+  - VOID_STATEMENT
+tokens:
+  # The order of the tokens at the beginning is important, because we use them
+  # for a lookup table.
+  - name: EOF
+    value: 1
+    comment: final token in the file
+  - name: BRACE_RIGHT
+    comment: "}"
+  - name: COMMA
+    comment: ","
+  - name: EMBEXPR_END
+    comment: "}"
+  - name: KEYWORD_DO
+    comment: "do"
+  - name: KEYWORD_ELSE
+    comment: "else"
+  - name: KEYWORD_ELSIF
+    comment: "elsif"
+  - name: KEYWORD_END
+    comment: "end"
+  - name: KEYWORD_ENSURE
+    comment: "ensure"
+  - name: KEYWORD_IN
+    comment: "in"
+  - name: KEYWORD_RESCUE
+    comment: "rescue"
+  - name: KEYWORD_THEN
+    comment: "then"
+  - name: KEYWORD_WHEN
+    comment: "when"
+  - name: NEWLINE
+    comment: "a newline character outside of other tokens"
+  - name: PARENTHESIS_RIGHT
+    comment: ")"
+  - name: SEMICOLON
+    comment: ";"
+  # Tokens from here on are not used for lookup, and can be in any order.
+  - name: AMPERSAND
+    comment: "&"
+  - name: AMPERSAND_AMPERSAND
+    comment: "&&"
+  - name: AMPERSAND_AMPERSAND_EQUAL
+    comment: "&&="
+  - name: AMPERSAND_DOT
+    comment: "&."
+  - name: AMPERSAND_EQUAL
+    comment: "&="
+  - name: BACKTICK
+    comment: "`"
+  - name: BACK_REFERENCE
+    comment: "a back reference"
+  - name: BANG
+    comment: "! or !@"
+  - name: BANG_EQUAL
+    comment: "!="
+  - name: BANG_TILDE
+    comment: "!~"
+  - name: BRACE_LEFT
+    comment: "{"
+  - name: BRACKET_LEFT
+    comment: "["
+  - name: BRACKET_LEFT_ARRAY
+    comment: "[ for the beginning of an array"
+  - name: BRACKET_LEFT_RIGHT
+    comment: "[]"
+  - name: BRACKET_LEFT_RIGHT_EQUAL
+    comment: "[]="
+  - name: BRACKET_RIGHT
+    comment: "]"
+  - name: CARET
+    comment: "^"
+  - name: CARET_EQUAL
+    comment: "^="
+  - name: CHARACTER_LITERAL
+    comment: "a character literal"
+  - name: CLASS_VARIABLE
+    comment: "a class variable"
+  - name: COLON
+    comment: ":"
+  - name: COLON_COLON
+    comment: "::"
+  - name: COMMENT
+    comment: "a comment"
+  - name: CONSTANT
+    comment: "a constant"
+  - name: DOT
+    comment: "the . call operator"
+  - name: DOT_DOT
+    comment: "the .. range operator"
+  - name: DOT_DOT_DOT
+    comment: "the ... range operator or forwarding parameter"
+  - name: EMBDOC_BEGIN
+    comment: "=begin"
+  - name: EMBDOC_END
+    comment: "=end"
+  - name: EMBDOC_LINE
+    comment: "a line inside of embedded documentation"
+  - name: EMBEXPR_BEGIN
+    comment: "#{"
+  - name: EMBVAR
+    comment: "#"
+  - name: EQUAL
+    comment: "="
+  - name: EQUAL_EQUAL
+    comment: "=="
+  - name: EQUAL_EQUAL_EQUAL
+    comment: "==="
+  - name: EQUAL_GREATER
+    comment: "=>"
+  - name: EQUAL_TILDE
+    comment: "=~"
+  - name: FLOAT
+    comment: "a floating point number"
+  - name: FLOAT_IMAGINARY
+    comment: "a floating pointer number with an imaginary suffix"
+  - name: FLOAT_RATIONAL
+    comment: "a floating pointer number with a rational suffix"
+  - name: FLOAT_RATIONAL_IMAGINARY
+    comment: "a floating pointer number with a rational and imaginary suffix"
+  - name: GLOBAL_VARIABLE
+    comment: "a global variable"
+  - name: GREATER
+    comment: ">"
+  - name: GREATER_EQUAL
+    comment: ">="
+  - name: GREATER_GREATER
+    comment: ">>"
+  - name: GREATER_GREATER_EQUAL
+    comment: ">>="
+  - name: HEREDOC_END
+    comment: "the end of a heredoc"
+  - name: HEREDOC_START
+    comment: "the start of a heredoc"
+  - name: IDENTIFIER
+    comment: "an identifier"
+  - name: IGNORED_NEWLINE
+    comment: "an ignored newline"
+  - name: INSTANCE_VARIABLE
+    comment: "an instance variable"
+  - name: INTEGER
+    comment: "an integer (any base)"
+  - name: INTEGER_IMAGINARY
+    comment: "an integer with an imaginary suffix"
+  - name: INTEGER_RATIONAL
+    comment: "an integer with a rational suffix"
+  - name: INTEGER_RATIONAL_IMAGINARY
+    comment: "an integer with a rational and imaginary suffix"
+  - name: KEYWORD_ALIAS
+    comment: "alias"
+  - name: KEYWORD_AND
+    comment: "and"
+  - name: KEYWORD_BEGIN
+    comment: "begin"
+  - name: KEYWORD_BEGIN_UPCASE
+    comment: "BEGIN"
+  - name: KEYWORD_BREAK
+    comment: "break"
+  - name: KEYWORD_CASE
+    comment: "case"
+  - name: KEYWORD_CLASS
+    comment: "class"
+  - name: KEYWORD_DEF
+    comment: "def"
+  - name: KEYWORD_DEFINED
+    comment: "defined?"
+  - name: KEYWORD_DO_LOOP
+    comment: "do keyword for a predicate in a while, until, or for loop"
+  - name: KEYWORD_END_UPCASE
+    comment: "END"
+  - name: KEYWORD_FALSE
+    comment: "false"
+  - name: KEYWORD_FOR
+    comment: "for"
+  - name: KEYWORD_IF
+    comment: "if"
+  - name: KEYWORD_IF_MODIFIER
+    comment: "if in the modifier form"
+  - name: KEYWORD_MODULE
+    comment: "module"
+  - name: KEYWORD_NEXT
+    comment: "next"
+  - name: KEYWORD_NIL
+    comment: "nil"
+  - name: KEYWORD_NOT
+    comment: "not"
+  - name: KEYWORD_OR
+    comment: "or"
+  - name: KEYWORD_REDO
+    comment: "redo"
+  - name: KEYWORD_RESCUE_MODIFIER
+    comment: "rescue in the modifier form"
+  - name: KEYWORD_RETRY
+    comment: "retry"
+  - name: KEYWORD_RETURN
+    comment: "return"
+  - name: KEYWORD_SELF
+    comment: "self"
+  - name: KEYWORD_SUPER
+    comment: "super"
+  - name: KEYWORD_TRUE
+    comment: "true"
+  - name: KEYWORD_UNDEF
+    comment: "undef"
+  - name: KEYWORD_UNLESS
+    comment: "unless"
+  - name: KEYWORD_UNLESS_MODIFIER
+    comment: "unless in the modifier form"
+  - name: KEYWORD_UNTIL
+    comment: "until"
+  - name: KEYWORD_UNTIL_MODIFIER
+    comment: "until in the modifier form"
+  - name: KEYWORD_WHILE
+    comment: "while"
+  - name: KEYWORD_WHILE_MODIFIER
+    comment: "while in the modifier form"
+  - name: KEYWORD_YIELD
+    comment: "yield"
+  - name: KEYWORD___ENCODING__
+    comment: "__ENCODING__"
+  - name: KEYWORD___FILE__
+    comment: "__FILE__"
+  - name: KEYWORD___LINE__
+    comment: "__LINE__"
+  - name: LABEL
+    comment: "a label"
+  - name: LABEL_END
+    comment: "the end of a label"
+  - name: LAMBDA_BEGIN
+    comment: "{"
+  - name: LESS
+    comment: "<"
+  - name: LESS_EQUAL
+    comment: "<="
+  - name: LESS_EQUAL_GREATER
+    comment: "<=>"
+  - name: LESS_LESS
+    comment: "<<"
+  - name: LESS_LESS_EQUAL
+    comment: "<<="
+  - name: METHOD_NAME
+    comment: "a method name"
+  - name: MINUS
+    comment: "-"
+  - name: MINUS_EQUAL
+    comment: "-="
+  - name: MINUS_GREATER
+    comment: "->"
+  - name: NUMBERED_REFERENCE
+    comment: "a numbered reference to a capture group in the previous regular expression match"
+  - name: PARENTHESIS_LEFT
+    comment: "("
+  - name: PARENTHESIS_LEFT_PARENTHESES
+    comment: "( for a parentheses node"
+  - name: PERCENT
+    comment: "%"
+  - name: PERCENT_EQUAL
+    comment: "%="
+  - name: PERCENT_LOWER_I
+    comment: "%i"
+  - name: PERCENT_LOWER_W
+    comment: "%w"
+  - name: PERCENT_LOWER_X
+    comment: "%x"
+  - name: PERCENT_UPPER_I
+    comment: "%I"
+  - name: PERCENT_UPPER_W
+    comment: "%W"
+  - name: PIPE
+    comment: "|"
+  - name: PIPE_EQUAL
+    comment: "|="
+  - name: PIPE_PIPE
+    comment: "||"
+  - name: PIPE_PIPE_EQUAL
+    comment: "||="
+  - name: PLUS
+    comment: "+"
+  - name: PLUS_EQUAL
+    comment: "+="
+  - name: QUESTION_MARK
+    comment: "?"
+  - name: REGEXP_BEGIN
+    comment: "the beginning of a regular expression"
+  - name: REGEXP_END
+    comment: "the end of a regular expression"
+  - name: SLASH
+    comment: "/"
+  - name: SLASH_EQUAL
+    comment: "/="
+  - name: STAR
+    comment: "*"
+  - name: STAR_EQUAL
+    comment: "*="
+  - name: STAR_STAR
+    comment: "**"
+  - name: STAR_STAR_EQUAL
+    comment: "**="
+  - name: STRING_BEGIN
+    comment: "the beginning of a string"
+  - name: STRING_CONTENT
+    comment: "the contents of a string"
+  - name: STRING_END
+    comment: "the end of a string"
+  - name: SYMBOL_BEGIN
+    comment: "the beginning of a symbol"
+  - name: TILDE
+    comment: "~ or ~@"
+  - name: UAMPERSAND
+    comment: "unary &"
+  - name: UCOLON_COLON
+    comment: "unary ::"
+  - name: UDOT_DOT
+    comment: "unary .. operator"
+  - name: UDOT_DOT_DOT
+    comment: "unary ... operator"
+  - name: UMINUS
+    comment: "-@"
+  - name: UMINUS_NUM
+    comment: "-@ for a number"
+  - name: UPLUS
+    comment: "+@"
+  - name: USTAR
+    comment: "unary *"
+  - name: USTAR_STAR
+    comment: "unary **"
+  - name: WORDS_SEP
+    comment: "a separator between words in a list"
+  - name: __END__
+    comment: "marker for the point in the file at which the parser should stop"
+  - name: MISSING
+    comment: "a token that was expected but not found"
+  - name: NOT_PROVIDED
+    comment: "a token that was not present but it is okay"
+flags:
+  - name: ArgumentsNodeFlags
+    values:
+      - name: CONTAINS_FORWARDING
+        comment: "if the arguments contain forwarding"
+      - name: CONTAINS_KEYWORDS
+        comment: "if the arguments contain keywords"
+      - name: CONTAINS_KEYWORD_SPLAT
+        comment: "if the arguments contain a keyword splat"
+      - name: CONTAINS_SPLAT
+        comment: "if the arguments contain a splat"
+      - name: CONTAINS_MULTIPLE_SPLATS
+        comment: "if the arguments contain multiple splats"
+    comment: Flags for arguments nodes.
+  - name: ArrayNodeFlags
+    values:
+      - name: CONTAINS_SPLAT
+        comment: "if array contains splat nodes"
+    comment: Flags for array nodes.
+  - name: CallNodeFlags
+    values:
+      - name: SAFE_NAVIGATION
+        comment: "&. operator"
+      - name: VARIABLE_CALL
+        comment: "a call that could have been a local variable"
+      - name: ATTRIBUTE_WRITE
+        comment: "a call that is an attribute write, so the value being written should be returned"
+      - name: IGNORE_VISIBILITY
+        comment: "a call that ignores method visibility"
+    comment: Flags for call nodes.
+  - name: EncodingFlags
+    values:
+      - name: FORCED_UTF8_ENCODING
+        comment: "internal bytes forced the encoding to UTF-8"
+      - name: FORCED_BINARY_ENCODING
+        comment: "internal bytes forced the encoding to binary"
+    comment: Flags for nodes that have unescaped content.
+  - name: IntegerBaseFlags
+    values:
+      - name: BINARY
+        comment: "0b prefix"
+      - name: DECIMAL
+        comment: "0d or no prefix"
+      - name: OCTAL
+        comment: "0o or 0 prefix"
+      - name: HEXADECIMAL
+        comment: "0x prefix"
+    comment: Flags for integer nodes that correspond to the base of the integer.
+  - name: InterpolatedStringNodeFlags
+    values:
+      - name: FROZEN
+        comment: "frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`"
+      - name: MUTABLE
+        comment: "mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`"
+    comment: Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
+  - name: KeywordHashNodeFlags
+    values:
+      - name: SYMBOL_KEYS
+        comment: "a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments"
+    comment: Flags for keyword hash nodes.
+  - name: LoopFlags
+    values:
+      - name: BEGIN_MODIFIER
+        comment: "a loop after a begin statement, so the body is executed first before the condition"
+    comment: Flags for while and until loop nodes.
+  - name: ParameterFlags
+    values:
+      - name: REPEATED_PARAMETER
+        comment: "a parameter name that has been repeated in the method signature"
+    comment: Flags for parameter nodes.
+  - name: ParenthesesNodeFlags
+    values:
+      - name: MULTIPLE_STATEMENTS
+        comment: "parentheses that contain multiple potentially void statements"
+    comment: Flags for parentheses nodes.
+  - name: RangeFlags
+    values:
+      - name: EXCLUDE_END
+        comment: "... operator"
+    comment: Flags for range and flip-flop nodes.
+  - name: RegularExpressionFlags
+    values:
+      - name: IGNORE_CASE
+        comment: "i - ignores the case of characters when matching"
+      - name: EXTENDED
+        comment: "x - ignores whitespace and allows comments in regular expressions"
+      - name: MULTI_LINE
+        comment: "m - allows $ to match the end of lines within strings"
+      - name: ONCE
+        comment: "o - only interpolates values into the regular expression once"
+      - name: EUC_JP
+        comment: "e - forces the EUC-JP encoding"
+      - name: ASCII_8BIT
+        comment: "n - forces the ASCII-8BIT encoding"
+      - name: WINDOWS_31J
+        comment: "s - forces the Windows-31J encoding"
+      - name: UTF_8
+        comment: "u - forces the UTF-8 encoding"
+      - name: FORCED_UTF8_ENCODING
+        comment: "internal bytes forced the encoding to UTF-8"
+      - name: FORCED_BINARY_ENCODING
+        comment: "internal bytes forced the encoding to binary"
+      - name: FORCED_US_ASCII_ENCODING
+        comment: "internal bytes forced the encoding to US-ASCII"
+    comment: Flags for regular expression and match last line nodes.
+  - name: ShareableConstantNodeFlags
+    values:
+      - name: LITERAL
+        comment: "constant writes that should be modified with shareable constant value literal"
+      - name: EXPERIMENTAL_EVERYTHING
+        comment: "constant writes that should be modified with shareable constant value experimental everything"
+      - name: EXPERIMENTAL_COPY
+        comment: "constant writes that should be modified with shareable constant value experimental copy"
+    comment: Flags for shareable constant nodes.
+  - name: StringFlags
+    values:
+      - name: FORCED_UTF8_ENCODING
+        comment: "internal bytes forced the encoding to UTF-8"
+      - name: FORCED_BINARY_ENCODING
+        comment: "internal bytes forced the encoding to binary"
+      - name: FROZEN
+        comment: "frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`"
+      - name: MUTABLE
+        comment: "mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`"
+    comment: Flags for string nodes.
+  - name: SymbolFlags
+    values:
+      - name: FORCED_UTF8_ENCODING
+        comment: "internal bytes forced the encoding to UTF-8"
+      - name: FORCED_BINARY_ENCODING
+        comment: "internal bytes forced the encoding to binary"
+      - name: FORCED_US_ASCII_ENCODING
+        comment: "internal bytes forced the encoding to US-ASCII"
+    comment: Flags for symbol nodes.
+nodes:
+  - name: AliasGlobalVariableNode
+    fields:
+      - name: new_name
+        type: node
+        kind:
+          - GlobalVariableReadNode
+          - BackReferenceReadNode
+          - NumberedReferenceReadNode
+        comment: |
+          Represents the new name of the global variable that can be used after aliasing.
+
+              alias $foo $bar
+                    ^^^^
+      - name: old_name
+        type: node
+        kind:
+          - GlobalVariableReadNode
+          - BackReferenceReadNode
+          - NumberedReferenceReadNode
+          - on error: SymbolNode # alias $a b
+          - on error: MissingNode # alias $a 42
+        comment: |
+          Represents the old name of the global variable that can be used before aliasing.
+
+              alias $foo $bar
+                         ^^^^
+      - name: keyword_loc
+        type: location
+        comment: |
+          The location of the `alias` keyword.
+
+              alias $foo $bar
+              ^^^^^
+    comment: |
+      Represents the use of the `alias` keyword to alias a global variable.
+
+          alias $foo $bar
+          ^^^^^^^^^^^^^^^
+  - name: AliasMethodNode
+    fields:
+      - name: new_name
+        type: node
+        kind:
+          - SymbolNode
+          - InterpolatedSymbolNode
+        comment: |
+          Represents the new name of the method that will be aliased.
+
+              alias foo bar
+                    ^^^
+
+              alias :foo :bar
+                    ^^^^
+
+              alias :"#{foo}" :"#{bar}"
+                    ^^^^^^^^^
+      - name: old_name
+        type: node
+        kind:
+          - SymbolNode
+          - InterpolatedSymbolNode
+          - on error: GlobalVariableReadNode # alias a $b
+          - on error: MissingNode # alias a 42
+        comment: |
+          Represents the old name of the method that will be aliased.
+
+              alias foo bar
+                        ^^^
+
+              alias :foo :bar
+                         ^^^^
+
+              alias :"#{foo}" :"#{bar}"
+                              ^^^^^^^^^
+      - name: keyword_loc
+        type: location
+        comment: |
+          Represents the location of the `alias` keyword.
+
+              alias foo bar
+              ^^^^^
+    comment: |
+      Represents the use of the `alias` keyword to alias a method.
+
+          alias foo bar
+          ^^^^^^^^^^^^^
+  - name: AlternationPatternNode
+    fields:
+      - name: left
+        type: node
+        kind: pattern expression
+        comment: |
+          Represents the left side of the expression.
+
+              foo => bar | baz
+                     ^^^
+      - name: right
+        type: node
+        kind: pattern expression
+        comment: |
+          Represents the right side of the expression.
+
+              foo => bar | baz
+                           ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          Represents the alternation operator location.
+
+              foo => bar | baz
+                         ^
+    comment: |
+      Represents an alternation pattern in pattern matching.
+
+          foo => bar | baz
+                 ^^^^^^^^^
+  - name: AndNode
+    fields:
+      - name: left
+        type: node
+        kind: non-void expression
+        comment: |
+          Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              left and right
+              ^^^^
+
+              1 && 2
+              ^
+      - name: right
+        type: node
+        kind: Node
+        comment: |
+          Represents the right side of the expression.
+
+              left && right
+                      ^^^^^
+
+              1 and 2
+                    ^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `and` keyword or the `&&` operator.
+
+              left and right
+                   ^^^
+    comment: |
+      Represents the use of the `&&` operator or the `and` keyword.
+
+          left and right
+          ^^^^^^^^^^^^^^
+  - name: ArgumentsNode
+    flags: ArgumentsNodeFlags
+    fields:
+      - name: arguments
+        type: node[]
+        kind: non-void expression
+        comment: |
+          The list of arguments, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo(bar, baz)
+                  ^^^^^^^^
+    comment: |
+      Represents a set of arguments to a method or a keyword.
+
+          return foo, bar, baz
+                 ^^^^^^^^^^^^^
+  - name: ArrayNode
+    flags: ArrayNodeFlags
+    fields:
+      - name: elements
+        type: node[]
+        kind: non-void expression
+        comment: Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
+      - name: opening_loc
+        type: location?
+        comment: |
+          Represents the optional source location for the opening token.
+
+              [1,2,3]                 # "["
+              %w[foo bar baz]         # "%w["
+              %I(apple orange banana) # "%I("
+              foo = 1, 2, 3           # nil
+      - name: closing_loc
+        type: location?
+        comment: |
+          Represents the optional source location for the closing token.
+
+              [1,2,3]                 # "]"
+              %w[foo bar baz]         # "]"
+              %I(apple orange banana) # ")"
+              foo = 1, 2, 3           # nil
+    comment: |
+      Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
+
+          [1, 2, 3]
+          ^^^^^^^^^
+  - name: ArrayPatternNode
+    fields:
+      - name: constant
+        type: node?
+        kind:
+          - ConstantPathNode
+          - ConstantReadNode
+        comment: |
+          Represents the optional constant preceding the Array
+
+              foo in Bar[]
+                     ^^^
+
+              foo in Bar[1, 2, 3]
+                     ^^^
+
+              foo in Bar::Baz[1, 2, 3]
+                     ^^^^^^^^
+      - name: requireds
+        type: node[]
+        kind: pattern expression
+        comment: |
+          Represents the required elements of the array pattern.
+
+              foo in [1, 2]
+                      ^  ^
+      - name: rest
+        type: node?
+        kind: pattern expression
+        comment: |
+          Represents the rest element of the array pattern.
+
+              foo in *bar
+                     ^^^^
+      - name: posts
+        type: node[]
+        kind: pattern expression
+        comment: |
+          Represents the elements after the rest element of the array pattern.
+
+              foo in *bar, baz
+                           ^^^
+      - name: opening_loc
+        type: location?
+        comment: |
+          Represents the opening location of the array pattern.
+
+              foo in [1, 2]
+                     ^
+      - name: closing_loc
+        type: location?
+        comment: |
+          Represents the closing location of the array pattern.
+
+              foo in [1, 2]
+                          ^
+    comment: |
+      Represents an array pattern in pattern matching.
+
+          foo in 1, 2
+          ^^^^^^^^^^^
+
+          foo in [1, 2]
+          ^^^^^^^^^^^^^
+
+          foo in *bar
+          ^^^^^^^^^^^
+
+          foo in Bar[]
+          ^^^^^^^^^^^^
+
+          foo in Bar[1, 2, 3]
+          ^^^^^^^^^^^^^^^^^^^
+  - name: AssocNode
+    fields:
+      - name: key
+        type: node
+        kind: non-void expression
+        comment: |
+          The key of the association. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              { a: b }
+                ^
+
+              { foo => bar }
+                ^^^
+
+              { def a; end => 1 }
+                ^^^^^^^^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          The value of the association, if present. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              { foo => bar }
+                       ^^^
+
+              { x: 1 }
+                   ^
+      - name: operator_loc
+        type: location?
+        comment: |
+          The location of the `=>` operator, if present.
+
+              { foo => bar }
+                    ^^
+    comment: |
+      Represents a hash key/value pair.
+
+          { a => b }
+            ^^^^^^
+  - name: AssocSplatNode
+    fields:
+      - name: value
+        type: node?
+        kind: non-void expression
+        comment: |
+          The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
+
+              { **foo }
+                  ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `**` operator.
+
+              { **x }
+                ^^
+    comment: |
+      Represents a splat in a hash literal.
+
+          { **foo }
+            ^^^^^
+  - name: BackReferenceReadNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the back-reference variable, including the leading `$`.
+
+              $& # name `:$&`
+
+              $+ # name `:$+`
+    comment: |
+      Represents reading a reference to a field in the previous match.
+
+          $'
+          ^^
+  - name: BeginNode
+    fields:
+      - name: begin_keyword_loc
+        type: location?
+        comment: |
+          Represents the location of the `begin` keyword.
+
+              begin x end
+              ^^^^^
+      - name: statements
+        type: node?
+        kind: StatementsNode
+        comment: |
+          Represents the statements within the begin block.
+
+              begin x end
+                    ^
+      - name: rescue_clause
+        type: node?
+        kind: RescueNode
+        comment: |
+          Represents the rescue clause within the begin block.
+
+              begin x; rescue y; end
+                       ^^^^^^^^
+      - name: else_clause
+        type: node?
+        kind: ElseNode
+        comment: |
+          Represents the else clause within the begin block.
+
+              begin x; rescue y; else z; end
+                                 ^^^^^^
+      - name: ensure_clause
+        type: node?
+        kind: EnsureNode
+        comment: |
+          Represents the ensure clause within the begin block.
+
+              begin x; ensure y; end
+                       ^^^^^^^^
+      - name: end_keyword_loc
+        type: location?
+        comment: |
+          Represents the location of the `end` keyword.
+
+              begin x end
+                      ^^^
+    newline: false
+    comment: |
+      Represents a begin statement.
+
+          begin
+            foo
+          end
+          ^^^^^
+  - name: BlockArgumentNode
+    fields:
+      - name: expression
+        type: node?
+        kind: non-void expression
+        comment: |
+          The expression that is being passed as a block argument. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo(&args)
+                  ^^^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          Represents the location of the `&` operator.
+
+              foo(&args)
+                  ^
+    comment: |
+      Represents a block argument using `&`.
+
+          bar(&args)
+          ^^^^^^^^^^
+  - name: BlockLocalVariableNode
+    flags: ParameterFlags
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the block local variable.
+
+              a { |; b| } # name `:b`
+                     ^
+    comment: |
+      Represents a block local variable.
+
+          a { |; b| }
+                 ^
+  - name: BlockNode
+    fields:
+      - name: locals
+        type: constant[]
+        comment: |
+          The local variables declared in the block.
+
+              [1, 2, 3].each { |i| puts x } # locals: [:i]
+                                ^
+      - name: parameters
+        type: node?
+        kind:
+          - BlockParametersNode
+          - NumberedParametersNode
+          - ItParametersNode
+        comment: |
+          The parameters of the block.
+
+              [1, 2, 3].each { |i| puts x }
+                               ^^^
+              [1, 2, 3].each { puts _1 }
+                             ^^^^^^^^^^^
+              [1, 2, 3].each { puts it }
+                             ^^^^^^^^^^^
+      - name: body
+        type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
+        comment: |
+          The body of the block.
+
+              [1, 2, 3].each { |i| puts x }
+                                   ^^^^^^
+      - name: opening_loc
+        type: location
+        comment: |
+          Represents the location of the opening `|`.
+
+              [1, 2, 3].each { |i| puts x }
+                               ^
+      - name: closing_loc
+        type: location
+        comment: |
+          Represents the location of the closing `|`.
+
+              [1, 2, 3].each { |i| puts x }
+                                 ^
+    comment: |
+      Represents a block of ruby code.
+
+          [1, 2, 3].each { |i| puts x }
+                         ^^^^^^^^^^^^^^
+  - name: BlockParameterNode
+    flags: ParameterFlags
+    fields:
+      - name: name
+        type: constant?
+        comment: |
+          The name of the block parameter.
+
+              def a(&b) # name `:b`
+                     ^
+              end
+      - name: name_loc
+        type: location?
+        comment: |
+          Represents the location of the block parameter name.
+
+              def a(&b)
+                     ^
+      - name: operator_loc
+        type: location
+        comment: |
+          Represents the location of the `&` operator.
+
+              def a(&b)
+                    ^
+              end
+    comment: |
+      Represents a block parameter of a method, block, or lambda definition.
+
+          def a(&b)
+                ^^
+          end
+  - name: BlockParametersNode
+    fields:
+      - name: parameters
+        type: node?
+        kind: ParametersNode
+        comment: |
+          Represents the parameters of the block.
+
+              -> (a, b = 1; local) { }
+                  ^^^^^^^^
+
+              foo do |a, b = 1; local|
+                      ^^^^^^^^
+              end
+      - name: locals
+        type: node[]
+        kind: BlockLocalVariableNode
+        comment: |
+          Represents the local variables of the block.
+
+              -> (a, b = 1; local) { }
+                            ^^^^^
+
+              foo do |a, b = 1; local|
+                                ^^^^^
+              end
+      - name: opening_loc
+        type: location?
+        comment: |
+          Represents the opening location of the block parameters.
+
+              -> (a, b = 1; local) { }
+                 ^
+
+              foo do |a, b = 1; local|
+                     ^
+              end
+      - name: closing_loc
+        type: location?
+        comment: |
+          Represents the closing location of the block parameters.
+
+              -> (a, b = 1; local) { }
+                                 ^
+
+              foo do |a, b = 1; local|
+                                     ^
+              end
+    comment: |
+      Represents a block's parameters declaration.
+
+          -> (a, b = 1; local) { }
+             ^^^^^^^^^^^^^^^^^
+
+          foo do |a, b = 1; local|
+                 ^^^^^^^^^^^^^^^^^
+          end
+  - name: BreakNode
+    fields:
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+        comment: |
+          The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              break foo
+                    ^^^
+      - name: keyword_loc
+        type: location
+        comment: |
+          The location of the `break` keyword.
+
+              break foo
+              ^^^^^
+    comment: |
+      Represents the use of the `break` keyword.
+
+          break foo
+          ^^^^^^^^^
+  - name: CallAndWriteNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node?
+        kind: non-void expression
+        comment: |
+          The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo.bar &&= value
+              ^^^
+      - name: call_operator_loc
+        type: location?
+        comment: |
+          Represents the location of the call operator.
+
+              foo.bar &&= value
+                 ^
+      - name: message_loc
+        type: location?
+        comment: |
+          Represents the location of the message.
+
+              foo.bar &&= value
+                  ^^^
+      - name: read_name
+        type: constant
+        comment: |
+          Represents the name of the method being called.
+
+              foo.bar &&= value # read_name `:bar`
+                  ^^^
+      - name: write_name
+        type: constant
+        comment: |
+          Represents the name of the method being written to.
+
+              foo.bar &&= value # write_name `:bar=`
+                  ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          Represents the location of the operator.
+
+              foo.bar &&= value
+                      ^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          Represents the value being assigned.
+
+              foo.bar &&= value
+                          ^^^^^
+    comment: |
+      Represents the use of the `&&=` operator on a call.
+
+          foo.bar &&= value
+          ^^^^^^^^^^^^^^^^^
+  - name: CallNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node?
+        kind: non-void expression
+        comment: |
+          The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo.bar
+              ^^^
+
+              +foo
+               ^^^
+
+              foo + bar
+              ^^^
+      - name: call_operator_loc
+        type: location?
+        comment: |
+          Represents the location of the call operator.
+
+              foo.bar
+                 ^
+
+              foo&.bar
+                 ^^
+      - name: name
+        type: constant
+        comment: |
+          Represents the name of the method being called.
+
+              foo.bar # name `:foo`
+              ^^^
+      - name: message_loc
+        type: location?
+        comment: |
+          Represents the location of the message.
+
+              foo.bar
+                  ^^^
+      - name: opening_loc
+        type: location?
+        comment: |
+          Represents the location of the left parenthesis.
+              foo(bar)
+                 ^
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+        comment: |
+          Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo(bar)
+                  ^^^
+      - name: closing_loc
+        type: location?
+        comment: |
+          Represents the location of the right parenthesis.
+
+              foo(bar)
+                     ^
+      - name: block
+        type: node?
+        kind:
+          - BlockNode
+          - BlockArgumentNode
+        comment: |
+          Represents the block that is being passed to the method.
+
+              foo { |a| a }
+                  ^^^^^^^^^
+    comment: |
+      Represents a method call, in all of the various forms that can take.
+
+          foo
+          ^^^
+
+          foo()
+          ^^^^^
+
+          +foo
+          ^^^^
+
+          foo + bar
+          ^^^^^^^^^
+
+          foo.bar
+          ^^^^^^^
+
+          foo&.bar
+          ^^^^^^^^
+  - name: CallOperatorWriteNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node?
+        kind: non-void expression
+        comment: |
+          The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo.bar += value
+              ^^^
+      - name: call_operator_loc
+        type: location?
+        comment: |
+          Represents the location of the call operator.
+
+              foo.bar += value
+                 ^
+      - name: message_loc
+        type: location?
+        comment: |
+          Represents the location of the message.
+
+              foo.bar += value
+                  ^^^
+      - name: read_name
+        type: constant
+        comment: |
+          Represents the name of the method being called.
+
+              foo.bar += value # read_name `:bar`
+                  ^^^
+      - name: write_name
+        type: constant
+        comment: |
+          Represents the name of the method being written to.
+
+              foo.bar += value # write_name `:bar=`
+                  ^^^
+      - name: binary_operator
+        type: constant
+        comment: |
+          Represents the binary operator being used.
+
+              foo.bar += value # binary_operator `:+`
+                      ^
+      - name: binary_operator_loc
+        type: location
+        comment: |
+          Represents the location of the binary operator.
+
+              foo.bar += value
+                      ^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          Represents the value being assigned.
+
+              foo.bar += value
+                         ^^^^^
+    comment: |
+      Represents the use of an assignment operator on a call.
+
+          foo.bar += baz
+          ^^^^^^^^^^^^^^
+  - name: CallOrWriteNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node?
+        kind: non-void expression
+        comment: |
+          The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo.bar ||= value
+              ^^^
+      - name: call_operator_loc
+        type: location?
+        comment: |
+          Represents the location of the call operator.
+
+              foo.bar ||= value
+                 ^
+      - name: message_loc
+        type: location?
+        comment: |
+          Represents the location of the message.
+
+              foo.bar ||= value
+                  ^^^
+      - name: read_name
+        type: constant
+        comment: |
+          Represents the name of the method being called.
+
+              foo.bar ||= value # read_name `:bar`
+                  ^^^
+      - name: write_name
+        type: constant
+        comment: |
+          Represents the name of the method being written to.
+
+              foo.bar ||= value # write_name `:bar=`
+                  ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          Represents the location of the operator.
+
+              foo.bar ||= value
+                      ^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          Represents the value being assigned.
+
+              foo.bar ||= value
+                          ^^^^^
+    comment: |
+      Represents the use of the `||=` operator on a call.
+
+          foo.bar ||= value
+          ^^^^^^^^^^^^^^^^^
+  - name: CallTargetNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node
+        kind: non-void expression
+        comment: |
+          The object that the method is being called on. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo.bar = 1
+              ^^^
+      - name: call_operator_loc
+        type: location
+        comment: |
+          Represents the location of the call operator.
+
+              foo.bar = 1
+                 ^
+      - name: name
+        type: constant
+        comment: |
+          Represents the name of the method being called.
+
+              foo.bar = 1 # name `:foo`
+              ^^^
+      - name: message_loc
+        type: location
+        comment: |
+          Represents the location of the message.
+
+              foo.bar = 1
+                  ^^^
+    comment: |
+      Represents assigning to a method call.
+
+          foo.bar, = 1
+          ^^^^^^^
+
+          begin
+          rescue => foo.bar
+                    ^^^^^^^
+          end
+
+          for foo.bar in baz do end
+              ^^^^^^^
+  - name: CapturePatternNode
+    fields:
+      - name: value
+        type: node
+        kind: pattern expression
+        comment: |
+          Represents the value to capture.
+
+              foo => bar
+                     ^^^
+      - name: target
+        type: node
+        kind: LocalVariableTargetNode
+        comment: |
+          Represents the target of the capture.
+
+              foo => bar
+              ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          Represents the location of the `=>` operator.
+
+              foo => bar
+                  ^^
+    comment: |
+      Represents assigning to a local variable in pattern matching.
+
+          foo => [bar => baz]
+                 ^^^^^^^^^^^^
+  - name: CaseMatchNode
+    fields:
+      - name: predicate
+        type: node?
+        kind: non-void expression
+        comment: |
+          Represents the predicate of the case match. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              case true; in false; end
+              ^^^^
+      - name: conditions
+        type: node[]
+        kind: InNode
+        comment: |
+          Represents the conditions of the case match.
+
+              case true; in false; end
+                         ^^^^^^^^
+      - name: else_clause
+        type: node?
+        kind: ElseNode
+        comment: |
+          Represents the else clause of the case match.
+
+              case true; in false; else; end
+                                   ^^^^
+      - name: case_keyword_loc
+        type: location
+        comment: |
+          Represents the location of the `case` keyword.
+
+              case true; in false; end
+              ^^^^
+      - name: end_keyword_loc
+        type: location
+        comment: |
+          Represents the location of the `end` keyword.
+
+              case true; in false; end
+                                   ^^^
+    comment: |
+      Represents the use of a case statement for pattern matching.
+
+          case true
+          in false
+          end
+          ^^^^^^^^^
+  - name: CaseNode
+    fields:
+      - name: predicate
+        type: node?
+        kind: non-void expression
+        comment: |
+          Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              case true; when false; end
+                   ^^^^
+      - name: conditions
+        type: node[]
+        kind: WhenNode
+        comment: |
+          Represents the conditions of the case statement.
+
+              case true; when false; end
+                         ^^^^^^^^^^
+      - name: else_clause
+        type: node?
+        kind: ElseNode
+        comment: |
+          Represents the else clause of the case statement.
+
+              case true; when false; else; end
+                                     ^^^^
+      - name: case_keyword_loc
+        type: location
+        comment: |
+          Represents the location of the `case` keyword.
+
+              case true; when false; end
+              ^^^^
+      - name: end_keyword_loc
+        type: location
+        comment: |
+          Represents the location of the `end` keyword.
+
+              case true; when false; end
+                                     ^^^
+    comment: |
+      Represents the use of a case statement.
+
+          case true
+          when false
+          end
+          ^^^^^^^^^^
+  - name: ClassNode
+    fields:
+      - name: locals
+        type: constant[]
+      - name: class_keyword_loc
+        type: location
+        comment: |
+          Represents the location of the `class` keyword.
+
+              class Foo end
+              ^^^^^
+      - name: constant_path
+        type: node
+        kind:
+          - ConstantReadNode
+          - ConstantPathNode
+          - on error: CallNode # class 0.X end
+      - name: inheritance_operator_loc
+        type: location?
+        comment: |
+          Represents the location of the `<` operator.
+
+              class Foo < Bar
+                        ^
+      - name: superclass
+        type: node?
+        kind: non-void expression
+        comment: |
+          Represents the superclass of the class.
+
+              class Foo < Bar
+                          ^^^
+      - name: body
+        type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
+        comment: |
+          Represents the body of the class.
+
+              class Foo
+                foo
+                ^^^
+      - name: end_keyword_loc
+        type: location
+        comment: |
+          Represents the location of the `end` keyword.
+
+              class Foo end
+                        ^^^
+      - name: name
+        type: constant
+        comment: |
+          The name of the class.
+
+              class Foo end # name `:Foo`
+    comment: |
+      Represents a class declaration involving the `class` keyword.
+
+          class Foo end
+          ^^^^^^^^^^^^^
+  - name: ClassVariableAndWriteNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+
+              @@target &&= value # name `:@@target`
+              ^^^^^^^^
+      - name: name_loc
+        type: location
+        comment: |
+          Represents the location of the variable name.
+
+              @@target &&= value
+              ^^^^^^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          Represents the location of the `&&=` operator.
+
+              @@target &&= value
+                       ^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          Represents the value being assigned. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              @@target &&= value
+                           ^^^^^
+    comment: |
+      Represents the use of the `&&=` operator for assignment to a class variable.
+
+          @@target &&= value
+          ^^^^^^^^^^^^^^^^^^
+  - name: ClassVariableOperatorWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: binary_operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: binary_operator
+        type: constant
+    comment: |
+      Represents assigning to a class variable using an operator that isn't `=`.
+
+          @@target += value
+          ^^^^^^^^^^^^^^^^^
+  - name: ClassVariableOrWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `||=` operator for assignment to a class variable.
+
+          @@target ||= value
+          ^^^^^^^^^^^^^^^^^^
+  - name: ClassVariableReadNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+
+              @@abc   # name `:@@abc`
+
+              @@_test # name `:@@_test`
+    comment: |
+      Represents referencing a class variable.
+
+          @@foo
+          ^^^^^
+  - name: ClassVariableTargetNode
+    fields:
+      - name: name
+        type: constant
+    comment: |
+      Represents writing to a class variable in a context that doesn't have an explicit value.
+
+          @@foo, @@bar = baz
+          ^^^^^  ^^^^^
+  - name: ClassVariableWriteNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+
+              @@abc = 123     # name `@@abc`
+
+              @@_test = :test # name `@@_test`
+      - name: name_loc
+        type: location
+        comment: |
+          The location of the variable name.
+
+              @@foo = :bar
+              ^^^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              @@foo = :bar
+                      ^^^^
+
+              @@_xyz = 123
+                       ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `=` operator.
+
+              @@foo = :bar
+                    ^
+    comment: |
+      Represents writing to a class variable.
+
+          @@foo = 1
+          ^^^^^^^^^
+  - name: ConstantAndWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `&&=` operator for assignment to a constant.
+
+          Target &&= value
+          ^^^^^^^^^^^^^^^^
+  - name: ConstantOperatorWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: binary_operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: binary_operator
+        type: constant
+    comment: |
+      Represents assigning to a constant using an operator that isn't `=`.
+
+          Target += value
+          ^^^^^^^^^^^^^^^
+  - name: ConstantOrWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `||=` operator for assignment to a constant.
+
+          Target ||= value
+          ^^^^^^^^^^^^^^^^
+  - name: ConstantPathAndWriteNode
+    fields:
+      - name: target
+        type: node
+        kind: ConstantPathNode
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `&&=` operator for assignment to a constant path.
+
+          Parent::Child &&= value
+          ^^^^^^^^^^^^^^^^^^^^^^^
+  - name: ConstantPathNode
+    fields:
+      - name: parent
+        type: node?
+        kind: non-void expression
+        comment: |
+          The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
+
+              Foo::Bar
+              ^^^
+
+              self::Test
+              ^^^^
+
+              a.b::C
+              ^^^
+      - name: name
+        type: constant?
+        comment: The name of the constant being accessed. This could be `nil` in the event of a syntax error.
+      - name: delimiter_loc
+        type: location
+        comment: |
+          The location of the `::` delimiter.
+
+              ::Foo
+              ^^
+
+              One::Two
+                 ^^
+      - name: name_loc
+        type: location
+        comment: |
+          The location of the name of the constant.
+
+              ::Foo
+                ^^^
+
+              One::Two
+                   ^^^
+    comment: |
+      Represents accessing a constant through a path of `::` operators.
+
+          Foo::Bar
+          ^^^^^^^^
+  - name: ConstantPathOperatorWriteNode
+    fields:
+      - name: target
+        type: node
+        kind: ConstantPathNode
+      - name: binary_operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: binary_operator
+        type: constant
+    comment: |
+      Represents assigning to a constant path using an operator that isn't `=`.
+
+          Parent::Child += value
+          ^^^^^^^^^^^^^^^^^^^^^^
+  - name: ConstantPathOrWriteNode
+    fields:
+      - name: target
+        type: node
+        kind: ConstantPathNode
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `||=` operator for assignment to a constant path.
+
+          Parent::Child ||= value
+          ^^^^^^^^^^^^^^^^^^^^^^^
+  - name: ConstantPathTargetNode
+    fields:
+      - name: parent
+        type: node?
+        kind: non-void expression
+      - name: name
+        type: constant?
+      - name: delimiter_loc
+        type: location
+      - name: name_loc
+        type: location
+    comment: |
+      Represents writing to a constant path in a context that doesn't have an explicit value.
+
+          Foo::Foo, Bar::Bar = baz
+          ^^^^^^^^  ^^^^^^^^
+  - name: ConstantPathWriteNode
+    fields:
+      - name: target
+        type: node
+        kind: ConstantPathNode
+        comment: |
+          A node representing the constant path being written to.
+
+              Foo::Bar = 1
+              ^^^^^^^^
+
+              ::Foo = :abc
+              ^^^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `=` operator.
+
+              ::ABC = 123
+                    ^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              FOO::BAR = :abc
+                         ^^^^
+    comment: |
+      Represents writing to a constant path.
+
+          ::Foo = 1
+          ^^^^^^^^^
+
+          Foo::Bar = 1
+          ^^^^^^^^^^^^
+
+          ::Foo::Bar = 1
+          ^^^^^^^^^^^^^^
+  - name: ConstantReadNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
+
+              X              # name `:X`
+
+              SOME_CONSTANT  # name `:SOME_CONSTANT`
+    comment: |
+      Represents referencing a constant.
+
+          Foo
+          ^^^
+  - name: ConstantTargetNode
+    fields:
+      - name: name
+        type: constant
+    comment: |
+      Represents writing to a constant in a context that doesn't have an explicit value.
+
+          Foo, Bar = baz
+          ^^^  ^^^
+  - name: ConstantWriteNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
+
+              Foo = :bar # name `:Foo`
+
+              XYZ = 1    # name `:XYZ`
+      - name: name_loc
+        type: location
+        comment: |
+          The location of the constant name.
+
+              FOO = 1
+              ^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              FOO = :bar
+                    ^^^^
+
+              MyClass = Class.new
+                        ^^^^^^^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `=` operator.
+
+              FOO = :bar
+                  ^
+    comment: |
+      Represents writing to a constant.
+
+          Foo = 1
+          ^^^^^^^
+  - name: DefNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: receiver
+        type: node?
+        kind: non-void expression
+      - name: parameters
+        type: node?
+        kind: ParametersNode
+      - name: body
+        type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
+      - name: locals
+        type: constant[]
+      - name: def_keyword_loc
+        type: location
+      - name: operator_loc
+        type: location?
+      - name: lparen_loc
+        type: location?
+      - name: rparen_loc
+        type: location?
+      - name: equal_loc
+        type: location?
+      - name: end_keyword_loc
+        type: location?
+    comment: |
+      Represents a method definition.
+
+          def method
+          end
+          ^^^^^^^^^^
+  - name: DefinedNode
+    fields:
+      - name: lparen_loc
+        type: location?
+      - name: value
+        type: node
+        kind: Node # More than non-void expression as defined?(return) is allowed, yet defined?(BEGIN{}) is SyntaxError
+      - name: rparen_loc
+        type: location?
+      - name: keyword_loc
+        type: location
+    comment: |
+      Represents the use of the `defined?` keyword.
+
+          defined?(a)
+          ^^^^^^^^^^^
+  - name: ElseNode
+    fields:
+      - name: else_keyword_loc
+        type: location
+      - name: statements
+        type: node?
+        kind: StatementsNode
+      - name: end_keyword_loc
+        type: location?
+    comment: |
+      Represents an `else` clause in a `case`, `if`, or `unless` statement.
+
+          if a then b else c end
+                      ^^^^^^^^^^
+  - name: EmbeddedStatementsNode
+    fields:
+      - name: opening_loc
+        type: location
+      - name: statements
+        type: node?
+        kind: StatementsNode
+      - name: closing_loc
+        type: location
+    comment: |
+      Represents an interpolated set of statements.
+
+          "foo #{bar}"
+               ^^^^^^
+  - name: EmbeddedVariableNode
+    fields:
+      - name: operator_loc
+        type: location
+      - name: variable
+        type: node
+        kind:
+          - InstanceVariableReadNode
+          - ClassVariableReadNode
+          - GlobalVariableReadNode
+          - BackReferenceReadNode
+          - NumberedReferenceReadNode
+    comment: |
+      Represents an interpolated variable.
+
+          "foo #@bar"
+               ^^^^^
+  - name: EnsureNode
+    fields:
+      - name: ensure_keyword_loc
+        type: location
+      - name: statements
+        type: node?
+        kind: StatementsNode
+      - name: end_keyword_loc
+        type: location
+    comment: |
+      Represents an `ensure` clause in a `begin` statement.
+
+          begin
+            foo
+          ensure
+          ^^^^^^
+            bar
+          end
+  - name: FalseNode
+    comment: |
+      Represents the use of the literal `false` keyword.
+
+          false
+          ^^^^^
+  - name: FindPatternNode
+    fields:
+      - name: constant
+        type: node?
+        kind:
+          - ConstantPathNode
+          - ConstantReadNode
+        comment: |
+          Represents the optional constant preceding the pattern
+
+              foo in Foo(*bar, baz, *qux)
+                     ^^^
+      - name: left
+        type: node
+        kind: SplatNode
+        comment: |
+          Represents the first wildcard node in the pattern.
+
+              foo in *bar, baz, *qux
+                     ^^^^
+
+              foo in Foo(*bar, baz, *qux)
+                         ^^^^
+      - name: requireds
+        type: node[]
+        kind: pattern expression
+        comment: |
+          Represents the nodes in between the wildcards.
+
+              foo in *bar, baz, *qux
+                           ^^^
+
+              foo in Foo(*bar, baz, 1, *qux)
+                               ^^^^^^
+      - name: right
+        type: node
+        kind:
+          - SplatNode
+          - on error: MissingNode
+        comment: |
+          Represents the second wildcard node in the pattern.
+
+              foo in *bar, baz, *qux
+                                ^^^^
+
+              foo in Foo(*bar, baz, *qux)
+                                    ^^^^
+      - name: opening_loc
+        type: location?
+        comment: |
+          The location of the opening brace.
+
+              foo in [*bar, baz, *qux]
+                     ^
+
+              foo in Foo(*bar, baz, *qux)
+                        ^
+      - name: closing_loc
+        type: location?
+        comment: |
+          The location of the closing brace.
+
+              foo in [*bar, baz, *qux]
+                                     ^
+
+              foo in Foo(*bar, baz, *qux)
+                                        ^
+    comment: |
+      Represents a find pattern in pattern matching.
+
+          foo in *bar, baz, *qux
+                 ^^^^^^^^^^^^^^^
+
+          foo in [*bar, baz, *qux]
+                 ^^^^^^^^^^^^^^^^^
+
+          foo in Foo(*bar, baz, *qux)
+                 ^^^^^^^^^^^^^^^^^^^^
+
+          foo => *bar, baz, *qux
+                 ^^^^^^^^^^^^^^^
+  - name: FlipFlopNode
+    flags: RangeFlags
+    fields:
+      - name: left
+        type: node?
+        kind: non-void expression
+      - name: right
+        type: node?
+        kind: non-void expression
+      - name: operator_loc
+        type: location
+    comment: |
+      Represents the use of the `..` or `...` operators to create flip flops.
+
+          baz if foo .. bar
+                 ^^^^^^^^^^
+  - name: FloatNode
+    fields:
+      - name: value
+        type: double
+        comment: The value of the floating point number as a Float.
+    comment: |
+      Represents a floating point number literal.
+
+          1.0
+          ^^^
+  - name: ForNode
+    fields:
+      - name: index
+        type: node
+        kind:
+          - LocalVariableTargetNode
+          - InstanceVariableTargetNode
+          - ClassVariableTargetNode
+          - GlobalVariableTargetNode
+          - ConstantTargetNode
+          - ConstantPathTargetNode
+          - CallTargetNode
+          - IndexTargetNode
+          - MultiTargetNode
+          - on error: BackReferenceReadNode # for $& in a end
+          - on error: NumberedReferenceReadNode # for $1 in a end
+          - on error: MissingNode # for in 1..10; end
+        comment: |
+          The index expression for `for` loops.
+
+              for i in a end
+                  ^
+      - name: collection
+        type: node
+        kind: non-void expression
+        comment: |
+          The collection to iterate over.
+
+              for i in a end
+                       ^
+      - name: statements
+        type: node?
+        kind: StatementsNode
+        comment: |
+          Represents the body of statements to execute for each iteration of the loop.
+
+              for i in a
+                foo(i)
+                ^^^^^^
+              end
+      - name: for_keyword_loc
+        type: location
+        comment: |
+          The location of the `for` keyword.
+
+              for i in a end
+              ^^^
+      - name: in_keyword_loc
+        type: location
+        comment: |
+          The location of the `in` keyword.
+
+              for i in a end
+                    ^^
+      - name: do_keyword_loc
+        type: location?
+        comment: |
+          The location of the `do` keyword, if present.
+
+              for i in a do end
+                         ^^
+      - name: end_keyword_loc
+        type: location
+        comment: |
+          The location of the `end` keyword.
+
+              for i in a end
+                         ^^^
+    comment: |
+      Represents the use of the `for` keyword.
+
+          for i in a end
+          ^^^^^^^^^^^^^^
+  - name: ForwardingArgumentsNode
+    comment: |
+      Represents forwarding all arguments to this method to another method.
+
+          def foo(...)
+            bar(...)
+                ^^^
+          end
+  - name: ForwardingParameterNode
+    comment: |
+      Represents the use of the forwarding parameter in a method, block, or lambda declaration.
+
+          def foo(...)
+                  ^^^
+          end
+  - name: ForwardingSuperNode
+    fields:
+      - name: block
+        type: node?
+        kind: BlockNode
+    comment: |
+      Represents the use of the `super` keyword without parentheses or arguments.
+
+          super
+          ^^^^^
+  - name: GlobalVariableAndWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `&&=` operator for assignment to a global variable.
+
+          $target &&= value
+          ^^^^^^^^^^^^^^^^^
+  - name: GlobalVariableOperatorWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: binary_operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: binary_operator
+        type: constant
+    comment: |
+      Represents assigning to a global variable using an operator that isn't `=`.
+
+          $target += value
+          ^^^^^^^^^^^^^^^^
+  - name: GlobalVariableOrWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `||=` operator for assignment to a global variable.
+
+          $target ||= value
+          ^^^^^^^^^^^^^^^^^
+  - name: GlobalVariableReadNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
+
+              $foo   # name `:$foo`
+
+              $_Test # name `:$_Test`
+    comment: |
+      Represents referencing a global variable.
+
+          $foo
+          ^^^^
+  - name: GlobalVariableTargetNode
+    fields:
+      - name: name
+        type: constant
+    comment: |
+      Represents writing to a global variable in a context that doesn't have an explicit value.
+
+          $foo, $bar = baz
+          ^^^^  ^^^^
+  - name: GlobalVariableWriteNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
+
+              $foo = :bar  # name `:$foo`
+
+              $_Test = 123 # name `:$_Test`
+      - name: name_loc
+        type: location
+        comment: |
+          The location of the global variable's name.
+
+              $foo = :bar
+              ^^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              $foo = :bar
+                     ^^^^
+
+              $-xyz = 123
+                      ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `=` operator.
+
+              $foo = :bar
+                   ^
+    comment: |
+      Represents writing to a global variable.
+
+          $foo = 1
+          ^^^^^^^^
+  - name: HashNode
+    fields:
+      - name: opening_loc
+        type: location
+        comment: |
+          The location of the opening brace.
+
+              { a => b }
+              ^
+      - name: elements
+        type: node[]
+        kind:
+          - AssocNode
+          - AssocSplatNode
+        comment: |
+          The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
+
+              { a: b }
+                ^^^^
+
+              { **foo }
+                ^^^^^
+      - name: closing_loc
+        type: location
+        comment: |
+          The location of the closing brace.
+
+              { a => b }
+                       ^
+    comment: |
+      Represents a hash literal.
+
+          { a => b }
+          ^^^^^^^^^^
+  - name: HashPatternNode
+    fields:
+      - name: constant
+        type: node?
+        kind:
+          - ConstantPathNode
+          - ConstantReadNode
+        comment: |
+          Represents the optional constant preceding the Hash.
+
+              foo => Bar[a: 1, b: 2]
+                   ^^^
+
+              foo => Bar::Baz[a: 1, b: 2]
+                   ^^^^^^^^
+      - name: elements
+        type: node[]
+        kind: AssocNode
+        comment: |
+          Represents the explicit named hash keys and values.
+
+              foo => { a: 1, b:, ** }
+                       ^^^^^^^^
+      - name: rest
+        type: node?
+        kind:
+          - AssocSplatNode
+          - NoKeywordsParameterNode
+        comment: |
+          Represents the rest of the Hash keys and values. This can be named, unnamed, or explicitly forbidden via `**nil`, this last one results in a `NoKeywordsParameterNode`.
+
+              foo => { a: 1, b:, **c }
+                                 ^^^
+
+              foo => { a: 1, b:, ** }
+                                 ^^
+
+              foo => { a: 1, b:, **nil }
+                                 ^^^^^
+      - name: opening_loc
+        type: location?
+        comment: |
+          The location of the opening brace.
+
+              foo => { a: 1 }
+                     ^
+
+              foo => Bar[a: 1]
+                        ^
+      - name: closing_loc
+        type: location?
+        comment: |
+          The location of the closing brace.
+
+              foo => { a: 1 }
+                            ^
+
+              foo => Bar[a: 1]
+                             ^
+    comment: |
+      Represents a hash pattern in pattern matching.
+
+          foo => { a: 1, b: 2 }
+                 ^^^^^^^^^^^^^^
+
+          foo => { a: 1, b: 2, **c }
+                 ^^^^^^^^^^^^^^^^^^^
+
+          foo => Bar[a: 1, b: 2]
+                 ^^^^^^^^^^^^^^^
+
+          foo in { a: 1, b: 2 }
+                 ^^^^^^^^^^^^^^
+  - name: IfNode
+    fields:
+      - name: if_keyword_loc
+        type: location?
+        comment: |
+          The location of the `if` keyword if present.
+
+              bar if foo
+                  ^^
+
+          The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
+      - name: predicate
+        type: node
+        kind: non-void expression
+        comment: |
+          The node for the condition the `IfNode` is testing.
+
+              if foo
+                 ^^^
+                bar
+              end
+
+              bar if foo
+                     ^^^
+
+              foo ? bar : baz
+              ^^^
+      - name: then_keyword_loc
+        type: location?
+        comment: |
+          The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
+
+              if foo then bar end
+                     ^^^^
+
+              a ? b : c
+                ^
+      - name: statements
+        type: node?
+        kind: StatementsNode
+        comment: |
+          Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
+
+              if foo
+                bar
+                ^^^
+                baz
+                ^^^
+              end
+      - name: subsequent
+        type: node?
+        kind:
+          - ElseNode
+          - IfNode
+        comment: |
+          Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
+
+              if foo
+                bar
+              elsif baz
+              ^^^^^^^^^
+                qux
+                ^^^
+              end
+              ^^^
+
+              if foo then bar else baz end
+                              ^^^^^^^^^^^^
+      - name: end_keyword_loc
+        type: location?
+        comment: |
+          The location of the `end` keyword if present, `nil` otherwise.
+
+              if foo
+                bar
+              end
+              ^^^
+    newline: predicate
+    comment: |
+      Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
+
+          bar if foo
+          ^^^^^^^^^^
+
+          if foo then bar end
+          ^^^^^^^^^^^^^^^^^^^
+
+          foo ? bar : baz
+          ^^^^^^^^^^^^^^^
+  - name: ImaginaryNode
+    fields:
+      - name: numeric
+        type: node
+        kind:
+          - FloatNode
+          - IntegerNode
+          - RationalNode
+    comment: |
+      Represents an imaginary number literal.
+
+          1.0i
+          ^^^^
+  - name: ImplicitNode
+    fields:
+      - name: value
+        type: node
+        kind:
+          - LocalVariableReadNode
+          - CallNode
+          - ConstantReadNode
+          - LocalVariableTargetNode
+    comment: |
+      Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
+
+          { foo: }
+            ^^^^
+
+          { Foo: }
+            ^^^^
+
+          foo in { bar: }
+                   ^^^^
+  - name: ImplicitRestNode
+    comment: |
+      Represents using a trailing comma to indicate an implicit rest parameter.
+
+          foo { |bar,| }
+                    ^
+
+          foo in [bar,]
+                     ^
+
+          for foo, in bar do end
+                 ^
+
+          foo, = bar
+             ^
+  - name: InNode
+    fields:
+      - name: pattern
+        type: node
+        kind: pattern expression
+      - name: statements
+        type: node?
+        kind: StatementsNode
+      - name: in_loc
+        type: location
+      - name: then_loc
+        type: location?
+    comment: |
+      Represents the use of the `in` keyword in a case statement.
+
+          case a; in b then c end
+                  ^^^^^^^^^^^
+  - name: IndexAndWriteNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node?
+        kind: non-void expression
+      - name: call_operator_loc
+        type: location?
+      - name: opening_loc
+        type: location
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+      - name: closing_loc
+        type: location
+      - name: block
+        type: node?
+        kind: BlockArgumentNode # foo[&b] &&= value, only valid on Ruby < 3.4
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `&&=` operator on a call to the `[]` method.
+
+          foo.bar[baz] &&= value
+          ^^^^^^^^^^^^^^^^^^^^^^
+  - name: IndexOperatorWriteNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node?
+        kind: non-void expression
+      - name: call_operator_loc
+        type: location?
+      - name: opening_loc
+        type: location
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+      - name: closing_loc
+        type: location
+      - name: block
+        type: node?
+        kind: BlockArgumentNode # foo[&b] += value, only valid on Ruby < 3.4
+      - name: binary_operator
+        type: constant
+      - name: binary_operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of an assignment operator on a call to `[]`.
+
+          foo.bar[baz] += value
+          ^^^^^^^^^^^^^^^^^^^^^
+  - name: IndexOrWriteNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node?
+        kind: non-void expression
+      - name: call_operator_loc
+        type: location?
+      - name: opening_loc
+        type: location
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+      - name: closing_loc
+        type: location
+      - name: block
+        type: node?
+        kind: BlockArgumentNode # foo[&b] ||= value, only valid on Ruby < 3.4
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `||=` operator on a call to `[]`.
+
+          foo.bar[baz] ||= value
+          ^^^^^^^^^^^^^^^^^^^^^^
+  - name: IndexTargetNode
+    flags: CallNodeFlags
+    fields:
+      - name: receiver
+        type: node
+        kind: non-void expression
+      - name: opening_loc
+        type: location
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+      - name: closing_loc
+        type: location
+      - name: block
+        type: node?
+        kind: BlockArgumentNode # foo[&b], = 1, only valid on Ruby < 3.4
+    comment: |
+      Represents assigning to an index.
+
+          foo[bar], = 1
+          ^^^^^^^^
+
+          begin
+          rescue => foo[bar]
+                    ^^^^^^^^
+          end
+
+          for foo[bar] in baz do end
+              ^^^^^^^^
+  - name: InstanceVariableAndWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `&&=` operator for assignment to an instance variable.
+
+          @target &&= value
+          ^^^^^^^^^^^^^^^^^
+  - name: InstanceVariableOperatorWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: binary_operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: binary_operator
+        type: constant
+    comment: |
+      Represents assigning to an instance variable using an operator that isn't `=`.
+
+          @target += value
+          ^^^^^^^^^^^^^^^^
+  - name: InstanceVariableOrWriteNode
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents the use of the `||=` operator for assignment to an instance variable.
+
+          @target ||= value
+          ^^^^^^^^^^^^^^^^^
+  - name: InstanceVariableReadNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+
+              @x     # name `:@x`
+
+              @_test # name `:@_test`
+    comment: |
+      Represents referencing an instance variable.
+
+          @foo
+          ^^^^
+  - name: InstanceVariableTargetNode
+    fields:
+      - name: name
+        type: constant
+    comment: |
+      Represents writing to an instance variable in a context that doesn't have an explicit value.
+
+          @foo, @bar = baz
+          ^^^^  ^^^^
+  - name: InstanceVariableWriteNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+
+              @x = :y       # name `:@x`
+
+              @_foo = "bar" # name `@_foo`
+      - name: name_loc
+        type: location
+        comment: |
+          The location of the variable name.
+
+              @_x = 1
+              ^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              @foo = :bar
+                     ^^^^
+
+              @_x = 1234
+                    ^^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `=` operator.
+
+              @x = y
+                 ^
+    comment: |
+      Represents writing to an instance variable.
+
+          @foo = 1
+          ^^^^^^^^
+  - name: IntegerNode
+    flags: IntegerBaseFlags
+    fields:
+      - name: value
+        type: integer
+        comment: The value of the integer literal as a number.
+    comment: |
+      Represents an integer number literal.
+
+          1
+          ^
+  - name: InterpolatedMatchLastLineNode
+    flags: RegularExpressionFlags
+    fields:
+      - name: opening_loc
+        type: location
+      - name: parts
+        type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
+      - name: closing_loc
+        type: location
+    newline: parts
+    comment: |
+      Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
+
+          if /foo #{bar} baz/ then end
+             ^^^^^^^^^^^^^^^^
+  - name: InterpolatedRegularExpressionNode
+    flags: RegularExpressionFlags
+    fields:
+      - name: opening_loc
+        type: location
+      - name: parts
+        type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
+      - name: closing_loc
+        type: location
+    newline: parts
+    comment: |
+      Represents a regular expression literal that contains interpolation.
+
+          /foo #{bar} baz/
+          ^^^^^^^^^^^^^^^^
+  - name: InterpolatedStringNode
+    flags: InterpolatedStringNodeFlags
+    fields:
+      - name: opening_loc
+        type: location?
+      - name: parts
+        type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
+          - InterpolatedStringNode # `"a" "#{b}"`
+          - on error: XStringNode # `<<`FOO` "bar"
+      - name: closing_loc
+        type: location?
+    newline: parts
+    comment: |
+      Represents a string literal that contains interpolation.
+
+          "foo #{bar} baz"
+          ^^^^^^^^^^^^^^^^
+  - name: InterpolatedSymbolNode
+    fields:
+      - name: opening_loc
+        type: location?
+      - name: parts
+        type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
+      - name: closing_loc
+        type: location?
+    newline: parts
+    comment: |
+      Represents a symbol literal that contains interpolation.
+
+          :"foo #{bar} baz"
+          ^^^^^^^^^^^^^^^^^
+  - name: InterpolatedXStringNode
+    fields:
+      - name: opening_loc
+        type: location
+      - name: parts
+        type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
+      - name: closing_loc
+        type: location
+    newline: parts
+    comment: |
+      Represents an xstring literal that contains interpolation.
+
+          `foo #{bar} baz`
+          ^^^^^^^^^^^^^^^^
+  - name: ItLocalVariableReadNode
+    comment: |
+      Represents reading from the implicit `it` local variable.
+
+          -> { it }
+               ^^
+  - name: ItParametersNode
+    comment: |
+      Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
+
+          -> { it + it }
+          ^^^^^^^^^^^^^^
+  - name: KeywordHashNode
+    flags: KeywordHashNodeFlags
+    fields:
+      - name: elements
+        type: node[]
+        kind:
+          - AssocNode
+          - AssocSplatNode
+    comment: |
+      Represents a hash literal without opening and closing braces.
+
+          foo(a: b)
+              ^^^^
+  - name: KeywordRestParameterNode
+    flags: ParameterFlags
+    fields:
+      - name: name
+        type: constant?
+      - name: name_loc
+        type: location?
+      - name: operator_loc
+        type: location
+    comment: |
+      Represents a keyword rest parameter to a method, block, or lambda definition.
+
+          def a(**b)
+                ^^^
+          end
+  - name: LambdaNode
+    fields:
+      - name: locals
+        type: constant[]
+      - name: operator_loc
+        type: location
+      - name: opening_loc
+        type: location
+      - name: closing_loc
+        type: location
+      - name: parameters
+        type: node?
+        kind:
+          - BlockParametersNode
+          - NumberedParametersNode
+          - ItParametersNode
+      - name: body
+        type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
+    comment: |
+      Represents using a lambda literal (not the lambda method call).
+
+          ->(value) { value * 2 }
+          ^^^^^^^^^^^^^^^^^^^^^^^
+  - name: LocalVariableAndWriteNode
+    fields:
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: name
+        type: constant
+      - name: depth
+        type: uint32
+    comment: |
+      Represents the use of the `&&=` operator for assignment to a local variable.
+
+          target &&= value
+          ^^^^^^^^^^^^^^^^
+  - name: LocalVariableOperatorWriteNode
+    fields:
+      - name: name_loc
+        type: location
+      - name: binary_operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: name
+        type: constant
+      - name: binary_operator
+        type: constant
+      - name: depth
+        type: uint32
+    comment: |
+      Represents assigning to a local variable using an operator that isn't `=`.
+
+          target += value
+          ^^^^^^^^^^^^^^^
+  - name: LocalVariableOrWriteNode
+    fields:
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: name
+        type: constant
+      - name: depth
+        type: uint32
+    comment: |
+      Represents the use of the `||=` operator for assignment to a local variable.
+
+          target ||= value
+          ^^^^^^^^^^^^^^^^
+  - name: LocalVariableReadNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+
+              x      # name `:x`
+
+              _Test  # name `:_Test`
+
+          Note that this can also be an underscore followed by a number for the default block parameters.
+
+              _1     # name `:_1`
+
+      - name: depth
+        type: uint32
+        comment: |
+          The number of visible scopes that should be searched to find the origin of this local variable.
+
+              foo = 1; foo # depth 0
+
+              bar = 2; tap { bar } # depth 1
+
+          The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
+    comment: |
+      Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
+
+          foo
+          ^^^
+  - name: LocalVariableTargetNode
+    fields:
+      - name: name
+        type: constant
+      - name: depth
+        type: uint32
+    comment: |
+      Represents writing to a local variable in a context that doesn't have an explicit value.
+
+          foo, bar = baz
+          ^^^  ^^^
+
+          foo => baz
+                 ^^^
+  - name: LocalVariableWriteNode
+    fields:
+      - name: name
+        type: constant
+        comment: |
+          The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+
+              foo = :bar # name `:foo`
+
+              abc = 123  # name `:abc`
+      - name: depth
+        type: uint32
+        comment: |
+          The number of semantic scopes we have to traverse to find the declaration of this variable.
+
+              foo = 1         # depth 0
+
+              tap { foo = 1 } # depth 1
+
+          The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
+      - name: name_loc
+        type: location
+        comment: |
+          The location of the variable name.
+
+              foo = :bar
+              ^^^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo = :bar
+                    ^^^^
+
+              abc = 1234
+                    ^^^^
+
+          Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
+
+              foo = foo
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `=` operator.
+
+              x = :y
+                ^
+    comment: |
+      Represents writing to a local variable.
+
+          foo = 1
+          ^^^^^^^
+  - name: MatchLastLineNode
+    flags: RegularExpressionFlags
+    fields:
+      - name: opening_loc
+        type: location
+      - name: content_loc
+        type: location
+      - name: closing_loc
+        type: location
+      - name: unescaped
+        type: string
+    comment: |
+      Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
+
+          if /foo/i then end
+             ^^^^^^
+  - name: MatchPredicateNode
+    fields:
+      - name: value
+        type: node
+        kind: non-void expression
+      - name: pattern
+        type: node
+        kind: pattern expression
+      - name: operator_loc
+        type: location
+    comment: |
+      Represents the use of the modifier `in` operator.
+
+          foo in bar
+          ^^^^^^^^^^
+  - name: MatchRequiredNode
+    fields:
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          Represents the left-hand side of the operator.
+
+              foo => bar
+              ^^^
+      - name: pattern
+        type: node
+        kind: pattern expression
+        comment: |
+          Represents the right-hand side of the operator. The type of the node depends on the expression.
+
+          Anything that looks like a local variable name (including `_`) will result in a `LocalVariableTargetNode`.
+
+              foo => a # This is equivalent to writing `a = foo`
+                     ^
+
+          Using an explicit `Array` or combining expressions with `,` will result in a `ArrayPatternNode`. This can be preceded by a constant.
+
+              foo => [a]
+                     ^^^
+
+              foo => a, b
+                     ^^^^
+
+              foo => Bar[a, b]
+                     ^^^^^^^^^
+
+          If the array pattern contains at least two wildcard matches, a `FindPatternNode` is created instead.
+
+              foo => *, 1, *a
+                     ^^^^^
+
+          Using an explicit `Hash` or a constant with square brackets and hash keys in the square brackets will result in a `HashPatternNode`.
+
+              foo => { a: 1, b: }
+
+              foo => Bar[a: 1, b:]
+
+              foo => Bar[**]
+
+          To use any variable that needs run time evaluation, pinning is required. This results in a `PinnedVariableNode`
+
+              foo => ^a
+                     ^^
+
+          Similar, any expression can be used with pinning. This results in a `PinnedExpressionNode`.
+
+              foo => ^(a + 1)
+
+          Anything else will result in the regular node for that expression, for example a `ConstantReadNode`.
+
+              foo => CONST
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the operator.
+
+              foo => bar
+                  ^^
+    comment: |
+      Represents the use of the `=>` operator.
+
+          foo => bar
+          ^^^^^^^^^^
+  - name: MatchWriteNode
+    fields:
+      - name: call
+        type: node
+        kind: CallNode
+      - name: targets
+        type: node[]
+        kind: LocalVariableTargetNode
+    comment: |
+      Represents writing local variables using a regular expression match with named capture groups.
+
+          /(?<foo>bar)/ =~ baz
+          ^^^^^^^^^^^^^^^^^^^^
+  - name: MissingNode
+    comment: |
+      Represents a node that is missing from the source and results in a syntax error.
+  - name: ModuleNode
+    fields:
+      - name: locals
+        type: constant[]
+      - name: module_keyword_loc
+        type: location
+      - name: constant_path
+        type: node
+        kind:
+          - ConstantReadNode
+          - ConstantPathNode
+          - on error: MissingNode # module Parent module end
+      - name: body
+        type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
+      - name: end_keyword_loc
+        type: location
+      - name: name
+        type: constant
+    comment: |
+      Represents a module declaration involving the `module` keyword.
+
+          module Foo end
+          ^^^^^^^^^^^^^^
+  - name: MultiTargetNode
+    fields:
+      - name: lefts
+        type: node[]
+        kind:
+          - LocalVariableTargetNode
+          - InstanceVariableTargetNode
+          - ClassVariableTargetNode
+          - GlobalVariableTargetNode
+          - ConstantTargetNode
+          - ConstantPathTargetNode
+          - CallTargetNode
+          - IndexTargetNode
+          - MultiTargetNode
+          - RequiredParameterNode # def m((a,b)); end
+          - on error: BackReferenceReadNode # a, (b, $&) = z
+          - on error: NumberedReferenceReadNode # a, (b, $1) = z
+        comment: |
+          Represents the targets expressions before a splat node.
+
+              a, (b, c, *) = 1, 2, 3, 4, 5
+                  ^^^^
+
+          The splat node can be absent, in that case all target expressions are in the left field.
+
+              a, (b, c) = 1, 2, 3, 4, 5
+                  ^^^^
+      - name: rest
+        type: node?
+        kind:
+          - ImplicitRestNode
+          - SplatNode
+        comment: |
+          Represents a splat node in the target expression.
+
+              a, (b, *c) = 1, 2, 3, 4
+                     ^^
+
+          The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
+
+              a, (b, *) = 1, 2, 3, 4
+                     ^
+
+          If the `*` is omitted, this field will contain an `ImplicitRestNode`
+
+              a, (b,) = 1, 2, 3, 4
+                   ^
+      - name: rights
+        type: node[]
+        kind:
+          - LocalVariableTargetNode
+          - InstanceVariableTargetNode
+          - ClassVariableTargetNode
+          - GlobalVariableTargetNode
+          - ConstantTargetNode
+          - ConstantPathTargetNode
+          - CallTargetNode
+          - IndexTargetNode
+          - MultiTargetNode
+          - RequiredParameterNode # def m((*,b)); end
+          - on error: BackReferenceReadNode # a, (*, $&) = z
+          - on error: NumberedReferenceReadNode # a, (*, $1) = z
+        comment: |
+          Represents the targets expressions after a splat node.
+
+              a, (*, b, c) = 1, 2, 3, 4, 5
+                     ^^^^
+      - name: lparen_loc
+        type: location?
+        comment: |
+          The location of the opening parenthesis.
+
+              a, (b, c) = 1, 2, 3
+                 ^
+      - name: rparen_loc
+        type: location?
+        comment: |
+          The location of the closing parenthesis.
+
+              a, (b, c) = 1, 2, 3
+                      ^
+    comment: |
+      Represents a multi-target expression.
+
+          a, (b, c) = 1, 2, 3
+             ^^^^^^
+
+      This can be a part of `MultiWriteNode` as above, or the target of a `for` loop
+
+          for a, b in [[1, 2], [3, 4]]
+              ^^^^
+  - name: MultiWriteNode
+    fields:
+      - name: lefts
+        type: node[]
+        kind:
+          - LocalVariableTargetNode
+          - InstanceVariableTargetNode
+          - ClassVariableTargetNode
+          - GlobalVariableTargetNode
+          - ConstantTargetNode
+          - ConstantPathTargetNode
+          - CallTargetNode
+          - IndexTargetNode
+          - MultiTargetNode
+          - on error: BackReferenceReadNode # $&, = z
+          - on error: NumberedReferenceReadNode # $1, = z
+        comment: |
+          Represents the targets expressions before a splat node.
+
+              a, b, * = 1, 2, 3, 4, 5
+              ^^^^
+
+          The splat node can be absent, in that case all target expressions are in the left field.
+
+              a, b, c = 1, 2, 3, 4, 5
+              ^^^^^^^
+      - name: rest
+        type: node?
+        kind:
+          - ImplicitRestNode
+          - SplatNode
+        comment: |
+          Represents a splat node in the target expression.
+
+              a, b, *c = 1, 2, 3, 4
+                    ^^
+
+          The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
+
+              a, b, * = 1, 2, 3, 4
+                    ^
+
+          If the `*` is omitted, this field will contain an `ImplicitRestNode`
+
+              a, b, = 1, 2, 3, 4
+                  ^
+      - name: rights
+        type: node[]
+        kind:
+          - LocalVariableTargetNode
+          - InstanceVariableTargetNode
+          - ClassVariableTargetNode
+          - GlobalVariableTargetNode
+          - ConstantTargetNode
+          - ConstantPathTargetNode
+          - CallTargetNode
+          - IndexTargetNode
+          - MultiTargetNode
+          - on error: BackReferenceReadNode # *, $& = z
+          - on error: NumberedReferenceReadNode # *, $1 = z
+        comment: |
+          Represents the targets expressions after a splat node.
+
+              a, *, b, c = 1, 2, 3, 4, 5
+                    ^^^^
+      - name: lparen_loc
+        type: location?
+        comment: |
+          The location of the opening parenthesis.
+
+              (a, b, c) = 1, 2, 3
+              ^
+      - name: rparen_loc
+        type: location?
+        comment: |
+          The location of the closing parenthesis.
+
+              (a, b, c) = 1, 2, 3
+                      ^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the operator.
+
+              a, b, c = 1, 2, 3
+                      ^
+      - name: value
+        type: node
+        kind: non-void expression
+        comment: |
+          The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              a, b, c = 1, 2, 3
+                        ^^^^^^^
+    comment: |
+      Represents a write to a multi-target expression.
+
+          a, b, c = 1, 2, 3
+          ^^^^^^^^^^^^^^^^^
+  - name: NextNode
+    fields:
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+      - name: keyword_loc
+        type: location
+    comment: |
+      Represents the use of the `next` keyword.
+
+          next 1
+          ^^^^^^
+  - name: NilNode
+    comment: |
+      Represents the use of the `nil` keyword.
+
+          nil
+          ^^^
+  - name: NoKeywordsParameterNode
+    fields:
+      - name: operator_loc
+        type: location
+      - name: keyword_loc
+        type: location
+    comment: |
+      Represents the use of `**nil` inside method arguments.
+
+          def a(**nil)
+                ^^^^^
+          end
+  - name: NumberedParametersNode
+    fields:
+      - name: maximum
+        type: uint8
+    comment: |
+      Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
+
+          -> { _1 + _2 }
+          ^^^^^^^^^^^^^^
+  - name: NumberedReferenceReadNode
+    fields:
+      - name: number
+        type: uint32
+        comment: |
+          The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`.
+
+              $1          # number `1`
+
+              $5432       # number `5432`
+
+              $4294967296 # number `0`
+    comment: |
+      Represents reading a numbered reference to a capture in the previous match.
+
+          $1
+          ^^
+  - name: OptionalKeywordParameterNode
+    flags: ParameterFlags
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents an optional keyword parameter to a method, block, or lambda definition.
+
+          def a(b: 1)
+                ^^^^
+          end
+  - name: OptionalParameterNode
+    flags: ParameterFlags
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: value
+        type: node
+        kind: non-void expression
+    comment: |
+      Represents an optional parameter to a method, block, or lambda definition.
+
+          def a(b = 1)
+                ^^^^^
+          end
+  - name: OrNode
+    fields:
+      - name: left
+        type: node
+        kind: non-void expression
+        comment: |
+          Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              left or right
+              ^^^^
+
+              1 || 2
+              ^
+      - name: right
+        type: node
+        kind: Node
+        comment: |
+          Represents the right side of the expression.
+
+              left || right
+                      ^^^^^
+
+              1 or 2
+                   ^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `or` keyword or the `||` operator.
+
+              left or right
+                   ^^
+    comment: |
+      Represents the use of the `||` operator or the `or` keyword.
+
+          left or right
+          ^^^^^^^^^^^^^
+  - name: ParametersNode
+    fields:
+      - name: requireds
+        type: node[]
+        kind:
+          - RequiredParameterNode
+          - MultiTargetNode
+      - name: optionals
+        type: node[]
+        kind: OptionalParameterNode
+      - name: rest
+        type: node?
+        kind:
+          - RestParameterNode
+          - ImplicitRestNode # Only in block parameters
+      - name: posts
+        type: node[]
+        kind:
+          - RequiredParameterNode
+          - MultiTargetNode
+          # On parsing error of `f(**kwargs, ...)` or `f(**nil, ...)`, the keyword_rest value is moved here:
+          - on error: KeywordRestParameterNode
+          - on error: NoKeywordsParameterNode
+          # On parsing error of `f(..., ...)`, the first forwarding parameter is moved here:
+          - on error: ForwardingParameterNode
+      - name: keywords
+        type: node[]
+        kind:
+          - RequiredKeywordParameterNode
+          - OptionalKeywordParameterNode
+      - name: keyword_rest
+        type: node?
+        kind:
+          - KeywordRestParameterNode
+          - ForwardingParameterNode
+          - NoKeywordsParameterNode
+      - name: block
+        type: node?
+        kind: BlockParameterNode
+    comment: |
+      Represents the list of parameters on a method, block, or lambda definition.
+
+          def a(b, c, d)
+                ^^^^^^^
+          end
+  - name: ParenthesesNode
+    flags: ParenthesesNodeFlags
+    fields:
+      - name: body
+        type: node?
+        kind: non-void expression # Usually a StatementsNode but not always e.g. `1 in (..10)`
+      - name: opening_loc
+        type: location
+      - name: closing_loc
+        type: location
+    newline: false
+    comment: |
+      Represents a parenthesized expression
+
+          (10 + 34)
+          ^^^^^^^^^
+  - name: PinnedExpressionNode
+    fields:
+      - name: expression
+        type: node
+        kind: non-void expression
+        comment: |
+          The expression used in the pinned expression
+
+              foo in ^(bar)
+                       ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `^` operator
+
+              foo in ^(bar)
+                     ^
+      - name: lparen_loc
+        type: location
+        comment: |
+          The location of the opening parenthesis.
+
+              foo in ^(bar)
+                      ^
+      - name: rparen_loc
+        type: location
+        comment: |
+          The location of the closing parenthesis.
+
+              foo in ^(bar)
+                          ^
+    comment: |
+      Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
+
+          foo in ^(bar)
+                 ^^^^^^
+  - name: PinnedVariableNode
+    fields:
+      - name: variable
+        type: node
+        kind:
+          - LocalVariableReadNode
+          - InstanceVariableReadNode
+          - ClassVariableReadNode
+          - GlobalVariableReadNode # foo in ^$a
+          - BackReferenceReadNode # foo in ^$&
+          - NumberedReferenceReadNode # foo in ^$1
+          - ItLocalVariableReadNode # proc { 1 in ^it }
+          - on error: MissingNode # foo in ^Bar
+        comment: |
+          The variable used in the pinned expression
+
+              foo in ^bar
+                      ^^^
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `^` operator
+
+              foo in ^bar
+                     ^
+    comment: |
+      Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
+
+          foo in ^bar
+                 ^^^^
+  - name: PostExecutionNode
+    fields:
+      - name: statements
+        type: node?
+        kind: StatementsNode
+      - name: keyword_loc
+        type: location
+      - name: opening_loc
+        type: location
+      - name: closing_loc
+        type: location
+    comment: |
+      Represents the use of the `END` keyword.
+
+          END { foo }
+          ^^^^^^^^^^^
+  - name: PreExecutionNode
+    fields:
+      - name: statements
+        type: node?
+        kind: StatementsNode
+      - name: keyword_loc
+        type: location
+      - name: opening_loc
+        type: location
+      - name: closing_loc
+        type: location
+    comment: |
+      Represents the use of the `BEGIN` keyword.
+
+          BEGIN { foo }
+          ^^^^^^^^^^^^^
+  - name: ProgramNode
+    fields:
+      - name: locals
+        type: constant[]
+      - name: statements
+        type: node
+        kind: StatementsNode
+    comment: The top level node of any parse tree.
+  - name: RangeNode
+    flags: RangeFlags
+    fields:
+      - name: left
+        type: node?
+        kind: non-void expression
+        comment: |
+          The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              1...
+              ^
+
+              hello...goodbye
+              ^^^^^
+      - name: right
+        type: node?
+        kind: non-void expression
+        comment: |
+          The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              ..5
+                ^
+
+              1...foo
+                  ^^^
+          If neither right-hand or left-hand side was included, this will be a MissingNode.
+      - name: operator_loc
+        type: location
+        comment: |
+          The location of the `..` or `...` operator.
+    comment: |
+      Represents the use of the `..` or `...` operators.
+
+          1..2
+          ^^^^
+
+          c if a =~ /left/ ... b =~ /right/
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  - name: RationalNode
+    flags: IntegerBaseFlags
+    fields:
+      - name: numerator
+        type: integer
+        comment: |
+          The numerator of the rational number.
+
+              1.5r # numerator 3
+      - name: denominator
+        type: integer
+        comment: |
+          The denominator of the rational number.
+
+              1.5r # denominator 2
+    comment: |
+      Represents a rational number literal.
+
+          1.0r
+          ^^^^
+  - name: RedoNode
+    comment: |
+      Represents the use of the `redo` keyword.
+
+          redo
+          ^^^^
+  - name: RegularExpressionNode
+    flags: RegularExpressionFlags
+    fields:
+      - name: opening_loc
+        type: location
+      - name: content_loc
+        type: location
+      - name: closing_loc
+        type: location
+      - name: unescaped
+        type: string
+    comment: |
+      Represents a regular expression literal with no interpolation.
+
+          /foo/i
+          ^^^^^^
+  - name: RequiredKeywordParameterNode
+    flags: ParameterFlags
+    fields:
+      - name: name
+        type: constant
+      - name: name_loc
+        type: location
+    comment: |
+      Represents a required keyword parameter to a method, block, or lambda definition.
+
+          def a(b: )
+                ^^
+          end
+  - name: RequiredParameterNode
+    flags: ParameterFlags
+    fields:
+      - name: name
+        type: constant
+    comment: |
+      Represents a required parameter to a method, block, or lambda definition.
+
+          def a(b)
+                ^
+          end
+  - name: RescueModifierNode
+    fields:
+      - name: expression
+        type: node
+        kind: Node
+      - name: keyword_loc
+        type: location
+      - name: rescue_expression
+        type: node
+        kind: Node
+    newline: expression
+    comment: |
+      Represents an expression modified with a rescue.
+
+          foo rescue nil
+          ^^^^^^^^^^^^^^
+  - name: RescueNode
+    fields:
+      - name: keyword_loc
+        type: location
+      - name: exceptions
+        type: node[]
+        kind: non-void expression
+      - name: operator_loc
+        type: location?
+      - name: reference
+        type: node?
+        kind:
+          - LocalVariableTargetNode
+          - InstanceVariableTargetNode
+          - ClassVariableTargetNode
+          - GlobalVariableTargetNode
+          - ConstantTargetNode
+          - ConstantPathTargetNode
+          - CallTargetNode
+          - IndexTargetNode
+          - on error: BackReferenceReadNode # => begin; rescue => $&; end
+          - on error: NumberedReferenceReadNode # => begin; rescue => $1; end
+          - on error: MissingNode # begin; rescue =>; end
+      - name: then_keyword_loc
+        type: location?
+      - name: statements
+        type: node?
+        kind: StatementsNode
+      - name: subsequent
+        type: node?
+        kind: RescueNode
+    comment: |
+      Represents a rescue statement.
+
+          begin
+          rescue Foo, *splat, Bar => ex
+            foo
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+          end
+
+      `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field.
+  - name: RestParameterNode
+    flags: ParameterFlags
+    fields:
+      - name: name
+        type: constant?
+      - name: name_loc
+        type: location?
+      - name: operator_loc
+        type: location
+    comment: |
+      Represents a rest parameter to a method, block, or lambda definition.
+
+          def a(*b)
+                ^^
+          end
+  - name: RetryNode
+    comment: |
+      Represents the use of the `retry` keyword.
+
+          retry
+          ^^^^^
+  - name: ReturnNode
+    fields:
+      - name: keyword_loc
+        type: location
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+    comment: |
+      Represents the use of the `return` keyword.
+
+          return 1
+          ^^^^^^^^
+  - name: SelfNode
+    comment: |
+      Represents the `self` keyword.
+
+          self
+          ^^^^
+  - name: ShareableConstantNode
+    flags: ShareableConstantNodeFlags
+    fields:
+      - name: write
+        type: node
+        kind:
+          - ConstantWriteNode
+          - ConstantAndWriteNode
+          - ConstantOrWriteNode
+          - ConstantOperatorWriteNode
+          - ConstantPathWriteNode
+          - ConstantPathAndWriteNode
+          - ConstantPathOrWriteNode
+          - ConstantPathOperatorWriteNode
+        comment: The constant write that should be modified with the shareability state.
+    comment: |
+      This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
+
+          # shareable_constant_value: literal
+          C = { a: 1 }
+          ^^^^^^^^^^^^
+  - name: SingletonClassNode
+    fields:
+      - name: locals
+        type: constant[]
+      - name: class_keyword_loc
+        type: location
+      - name: operator_loc
+        type: location
+      - name: expression
+        type: node
+        kind: non-void expression
+      - name: body
+        type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
+      - name: end_keyword_loc
+        type: location
+    comment: |
+      Represents a singleton class declaration involving the `class` keyword.
+
+          class << self end
+          ^^^^^^^^^^^^^^^^^
+  - name: SourceEncodingNode
+    comment: |
+      Represents the use of the `__ENCODING__` keyword.
+
+          __ENCODING__
+          ^^^^^^^^^^^^
+  - name: SourceFileNode
+    flags: StringFlags
+    fields:
+      - name: filepath
+        type: string
+        comment: Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
+    comment: |
+      Represents the use of the `__FILE__` keyword.
+
+          __FILE__
+          ^^^^^^^^
+  - name: SourceLineNode
+    comment: |
+      Represents the use of the `__LINE__` keyword.
+
+          __LINE__
+          ^^^^^^^^
+  - name: SplatNode
+    fields:
+      - name: operator_loc
+        type: location
+      - name: expression
+        type: node?
+        kind: non-void expression
+    comment: |
+      Represents the use of the splat operator.
+
+          [*a]
+           ^^
+  - name: StatementsNode
+    fields:
+      - name: body
+        type: node[]
+        kind: Node
+    comment: |
+      Represents a set of statements contained within some scope.
+
+          foo; bar; baz
+          ^^^^^^^^^^^^^
+  - name: StringNode
+    flags: StringFlags
+    fields:
+      - name: opening_loc
+        type: location?
+      - name: content_loc
+        type: location
+      - name: closing_loc
+        type: location?
+      - name: unescaped
+        type: string
+    comment: |
+      Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
+
+          "foo"
+          ^^^^^
+
+          %w[foo]
+             ^^^
+
+          "foo #{bar} baz"
+           ^^^^      ^^^^
+  - name: SuperNode
+    fields:
+      - name: keyword_loc
+        type: location
+      - name: lparen_loc
+        type: location?
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+      - name: rparen_loc
+        type: location?
+      - name: block
+        type: node?
+        kind:
+          - BlockNode
+          - BlockArgumentNode
+    comment: |
+      Represents the use of the `super` keyword with parentheses or arguments.
+
+          super()
+          ^^^^^^^
+
+          super foo, bar
+          ^^^^^^^^^^^^^^
+  - name: SymbolNode
+    flags: SymbolFlags
+    fields:
+      - name: opening_loc
+        type: location?
+      - name: value_loc
+        type: location?
+      - name: closing_loc
+        type: location?
+      - name: unescaped
+        type: string
+    comment: |
+      Represents a symbol literal or a symbol contained within a `%i` list.
+
+          :foo
+          ^^^^
+
+          %i[foo]
+             ^^^
+  - name: TrueNode
+    comment: |
+      Represents the use of the literal `true` keyword.
+
+          true
+          ^^^^
+  - name: UndefNode
+    fields:
+      - name: names
+        type: node[]
+        kind:
+          - SymbolNode
+          - InterpolatedSymbolNode
+      - name: keyword_loc
+        type: location
+    comment: |
+      Represents the use of the `undef` keyword.
+
+          undef :foo, :bar, :baz
+          ^^^^^^^^^^^^^^^^^^^^^^
+  - name: UnlessNode
+    fields:
+      - name: keyword_loc
+        type: location
+        comment: |
+          The location of the `unless` keyword.
+
+              unless cond then bar end
+              ^^^^^^
+
+              bar unless cond
+                  ^^^^^^
+      - name: predicate
+        type: node
+        kind: non-void expression
+        comment: |
+          The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              unless cond then bar end
+                     ^^^^
+
+              bar unless cond
+                         ^^^^
+      - name: then_keyword_loc
+        type: location?
+        comment: |
+          The location of the `then` keyword, if present.
+
+              unless cond then bar end
+                          ^^^^
+      - name: statements
+        type: node?
+        kind: StatementsNode
+        comment: |
+          The body of statements that will executed if the unless condition is
+          falsey. Will be `nil` if no body is provided.
+
+              unless cond then bar end
+                               ^^^
+      - name: else_clause
+        type: node?
+        kind: ElseNode
+        comment: |
+          The else clause of the unless expression, if present.
+
+              unless cond then bar else baz end
+                                   ^^^^^^^^
+      - name: end_keyword_loc
+        type: location?
+        comment: |
+          The location of the `end` keyword, if present.
+
+              unless cond then bar end
+                                   ^^^
+    newline: predicate
+    comment: |
+      Represents the use of the `unless` keyword, either in the block form or the modifier form.
+
+          bar unless foo
+          ^^^^^^^^^^^^^^
+
+          unless foo then bar end
+          ^^^^^^^^^^^^^^^^^^^^^^^
+  - name: UntilNode
+    flags: LoopFlags
+    fields:
+      - name: keyword_loc
+        type: location
+      - name: do_keyword_loc
+        type: location?
+      - name: closing_loc
+        type: location?
+      - name: predicate
+        type: node
+        kind: non-void expression
+      - name: statements
+        type: node?
+        kind: StatementsNode
+    newline: predicate
+    comment: |
+      Represents the use of the `until` keyword, either in the block form or the modifier form.
+
+          bar until foo
+          ^^^^^^^^^^^^^
+
+          until foo do bar end
+          ^^^^^^^^^^^^^^^^^^^^
+  - name: WhenNode
+    fields:
+      - name: keyword_loc
+        type: location
+      - name: conditions
+        type: node[]
+        kind: non-void expression
+      - name: then_keyword_loc
+        type: location?
+      - name: statements
+        type: node?
+        kind: StatementsNode
+    comment: |
+      Represents the use of the `when` keyword within a case statement.
+
+          case true
+          when true
+          ^^^^^^^^^
+          end
+  - name: WhileNode
+    flags: LoopFlags
+    fields:
+      - name: keyword_loc
+        type: location
+      - name: do_keyword_loc
+        type: location?
+      - name: closing_loc
+        type: location?
+      - name: predicate
+        type: node
+        kind: non-void expression
+      - name: statements
+        type: node?
+        kind: StatementsNode
+    newline: predicate
+    comment: |
+      Represents the use of the `while` keyword, either in the block form or the modifier form.
+
+          bar while foo
+          ^^^^^^^^^^^^^
+
+          while foo do bar end
+          ^^^^^^^^^^^^^^^^^^^^
+  - name: XStringNode
+    flags: EncodingFlags
+    fields:
+      - name: opening_loc
+        type: location
+      - name: content_loc
+        type: location
+      - name: closing_loc
+        type: location
+      - name: unescaped
+        type: string
+    comment: |
+      Represents an xstring literal with no interpolation.
+
+          `foo`
+          ^^^^^
+  - name: YieldNode
+    fields:
+      - name: keyword_loc
+        type: location
+      - name: lparen_loc
+        type: location?
+      - name: arguments
+        type: node?
+        kind: ArgumentsNode
+      - name: rparen_loc
+        type: location?
+    comment: |
+      Represents the use of the `yield` keyword.
+
+          yield 1
+          ^^^^^^^