config.yml

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_CAPTURE_IN_ALTERNATIVE
  - 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_PARAMETER_DEFAULT_VALUE
  - 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: PIPE
    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_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 `{` or `do`.

              [1, 2, 3].each { |i| puts x }
                             ^
      - name: closing_loc
        type: location
        comment: |
          Represents the location of the closing `}` or `end`.

              [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: equal_loc
        type: location?
        comment: |
          Represents the location of the equal sign, in the case that this is an attribute write.

              foo.bar = value
                      ^

              foo[bar] = value
                       ^
      - 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: |
          All other arguments are forwarded as normal, except the original block is replaced with the new block.
    comment: |
      Represents the use of the `super` keyword without parentheses or arguments, but which might have a block.

          super
          ^^^^^

          super { 123 }
          ^^^^^^^^^^^^^

      If it has any other arguments, it would be a `SuperNode` instead.
  - 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"
          - on error: InterpolatedXStringNode
          - on error: SymbolNode
          - on error: InterpolatedSymbolNode
      - 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
        comment: "Can be only `nil` when there are empty parentheses, like `super()`."
      - 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
          ^^^^^^^^^^^^^^

      If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead.
  - 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
          ^^^^^^^