jruby-prism-parser 0.24.0-java → 1.4.0-java

data/config.yml

@@ -1,3 +1,324 @@
+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_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_REQ_PARAMETER
+  - EXPECT_MESSAGE
+  - EXPECT_RBRACKET
+  - EXPECT_RPAREN
+  - EXPECT_RPAREN_AFTER_MULTI
+  - EXPECT_RPAREN_REQ_PARAMETER
+  - EXPECT_SINGLETON_CLASS_DELIMITER
+  - EXPECT_STRING_CONTENT
+  - EXPECT_WHEN_DELIMITER
+  - EXPRESSION_BARE_HASH
+  - EXPRESSION_NOT_WRITABLE
+  - EXPRESSION_NOT_WRITABLE_ENCODING
+  - EXPRESSION_NOT_WRITABLE_FALSE
+  - EXPRESSION_NOT_WRITABLE_FILE
+  - EXPRESSION_NOT_WRITABLE_LINE
+  - EXPRESSION_NOT_WRITABLE_NIL
+  - EXPRESSION_NOT_WRITABLE_NUMBERED
+  - EXPRESSION_NOT_WRITABLE_SELF
+  - EXPRESSION_NOT_WRITABLE_TRUE
+  - FLOAT_PARSE
+  - FOR_COLLECTION
+  - FOR_IN
+  - FOR_INDEX
+  - FOR_TERM
+  - GLOBAL_VARIABLE_BARE
+  - HASH_EXPRESSION_AFTER_LABEL
+  - HASH_KEY
+  - HASH_ROCKET
+  - HASH_TERM
+  - HASH_VALUE
+  - HEREDOC_IDENTIFIER
+  - HEREDOC_TERM
+  - INCOMPLETE_QUESTION_MARK
+  - INCOMPLETE_VARIABLE_CLASS
+  - INCOMPLETE_VARIABLE_CLASS_3_3
+  - INCOMPLETE_VARIABLE_INSTANCE
+  - INCOMPLETE_VARIABLE_INSTANCE_3_3
+  - INSTANCE_VARIABLE_BARE
+  - INVALID_BLOCK_EXIT
+  - INVALID_CHARACTER
+  - INVALID_COMMA
+  - INVALID_ENCODING_MAGIC_COMMENT
+  - INVALID_ESCAPE_CHARACTER
+  - INVALID_FLOAT_EXPONENT
+  - INVALID_LOCAL_VARIABLE_READ
+  - INVALID_LOCAL_VARIABLE_WRITE
+  - INVALID_MULTIBYTE_CHAR
+  - INVALID_MULTIBYTE_CHARACTER
+  - INVALID_MULTIBYTE_ESCAPE
+  - INVALID_NUMBER_BINARY
+  - INVALID_NUMBER_DECIMAL
+  - INVALID_NUMBER_FRACTION
+  - INVALID_NUMBER_HEXADECIMAL
+  - INVALID_NUMBER_OCTAL
+  - INVALID_NUMBER_UNDERSCORE_INNER
+  - INVALID_NUMBER_UNDERSCORE_TRAILING
+  - INVALID_PERCENT
+  - INVALID_PERCENT_EOF
+  - INVALID_PRINTABLE_CHARACTER
+  - INVALID_RETRY_AFTER_ELSE
+  - INVALID_RETRY_AFTER_ENSURE
+  - INVALID_RETRY_WITHOUT_RESCUE
+  - INVALID_SYMBOL
+  - INVALID_VARIABLE_GLOBAL
+  - INVALID_VARIABLE_GLOBAL_3_3
+  - INVALID_YIELD
+  - IT_NOT_ALLOWED_NUMBERED
+  - IT_NOT_ALLOWED_ORDINARY
+  - LAMBDA_OPEN
+  - LAMBDA_TERM_BRACE
+  - LAMBDA_TERM_END
+  - LIST_I_LOWER_ELEMENT
+  - LIST_I_LOWER_TERM
+  - LIST_I_UPPER_ELEMENT
+  - LIST_I_UPPER_TERM
+  - LIST_W_LOWER_ELEMENT
+  - LIST_W_LOWER_TERM
+  - LIST_W_UPPER_ELEMENT
+  - LIST_W_UPPER_TERM
+  - MALLOC_FAILED
+  - MIXED_ENCODING
+  - MODULE_IN_METHOD
+  - MODULE_NAME
+  - MODULE_TERM
+  - MULTI_ASSIGN_MULTI_SPLATS
+  - MULTI_ASSIGN_UNEXPECTED_REST
+  - NESTING_TOO_DEEP
+  - NO_LOCAL_VARIABLE
+  - NON_ASSOCIATIVE_OPERATOR
+  - NOT_EXPRESSION
+  - NUMBER_LITERAL_UNDERSCORE
+  - NUMBERED_PARAMETER_INNER_BLOCK
+  - NUMBERED_PARAMETER_IT
+  - NUMBERED_PARAMETER_ORDINARY
+  - NUMBERED_PARAMETER_OUTER_BLOCK
+  - OPERATOR_MULTI_ASSIGN
+  - OPERATOR_WRITE_ARGUMENTS
+  - OPERATOR_WRITE_BLOCK
+  - PARAMETER_ASSOC_SPLAT_MULTI
+  - PARAMETER_BLOCK_MULTI
+  - PARAMETER_CIRCULAR
+  - PARAMETER_FORWARDING_AFTER_REST
+  - PARAMETER_METHOD_NAME
+  - PARAMETER_NAME_DUPLICATED
+  - PARAMETER_NO_DEFAULT
+  - PARAMETER_NO_DEFAULT_KW
+  - PARAMETER_NUMBERED_RESERVED
+  - PARAMETER_ORDER
+  - PARAMETER_SPLAT_MULTI
+  - PARAMETER_STAR
+  - PARAMETER_UNEXPECTED_FWD
+  - PARAMETER_UNEXPECTED_NO_KW
+  - PARAMETER_WILD_LOOSE_COMMA
+  - PATTERN_ARRAY_MULTIPLE_RESTS
+  - PATTERN_CAPTURE_DUPLICATE
+  - PATTERN_EXPRESSION_AFTER_BRACKET
+  - PATTERN_EXPRESSION_AFTER_COMMA
+  - PATTERN_EXPRESSION_AFTER_HROCKET
+  - PATTERN_EXPRESSION_AFTER_IN
+  - PATTERN_EXPRESSION_AFTER_KEY
+  - PATTERN_EXPRESSION_AFTER_PAREN
+  - PATTERN_EXPRESSION_AFTER_PIN
+  - PATTERN_EXPRESSION_AFTER_PIPE
+  - PATTERN_EXPRESSION_AFTER_RANGE
+  - PATTERN_EXPRESSION_AFTER_REST
+  - PATTERN_FIND_MISSING_INNER
+  - PATTERN_HASH_IMPLICIT
+  - PATTERN_HASH_KEY
+  - PATTERN_HASH_KEY_DUPLICATE
+  - PATTERN_HASH_KEY_INTERPOLATED
+  - PATTERN_HASH_KEY_LABEL
+  - PATTERN_HASH_KEY_LOCALS
+  - PATTERN_IDENT_AFTER_HROCKET
+  - PATTERN_LABEL_AFTER_COMMA
+  - PATTERN_REST
+  - PATTERN_TERM_BRACE
+  - PATTERN_TERM_BRACKET
+  - PATTERN_TERM_PAREN
+  - PIPEPIPEEQ_MULTI_ASSIGN
+  - REGEXP_ENCODING_OPTION_MISMATCH
+  - REGEXP_INCOMPAT_CHAR_ENCODING
+  - REGEXP_INVALID_UNICODE_RANGE
+  - REGEXP_NON_ESCAPED_MBC
+  - REGEXP_PARSE_ERROR
+  - REGEXP_TERM
+  - REGEXP_UNKNOWN_OPTIONS
+  - REGEXP_UTF8_CHAR_NON_UTF8_REGEXP
+  - RESCUE_EXPRESSION
+  - RESCUE_MODIFIER_VALUE
+  - RESCUE_TERM
+  - RESCUE_VARIABLE
+  - RETURN_INVALID
+  - SCRIPT_NOT_FOUND
+  - SINGLETON_FOR_LITERALS
+  - STATEMENT_ALIAS
+  - STATEMENT_POSTEXE_END
+  - STATEMENT_PREEXE_BEGIN
+  - STATEMENT_UNDEF
+  - STRING_CONCATENATION
+  - STRING_INTERPOLATED_TERM
+  - STRING_LITERAL_EOF
+  - STRING_LITERAL_TERM
+  - SYMBOL_INVALID
+  - SYMBOL_TERM_DYNAMIC
+  - SYMBOL_TERM_INTERPOLATED
+  - TERNARY_COLON
+  - TERNARY_EXPRESSION_FALSE
+  - TERNARY_EXPRESSION_TRUE
+  - UNARY_DISALLOWED
+  - UNARY_RECEIVER
+  - UNDEF_ARGUMENT
+  - UNEXPECTED_BLOCK_ARGUMENT
+  - UNEXPECTED_INDEX_BLOCK
+  - UNEXPECTED_INDEX_KEYWORDS
+  - UNEXPECTED_LABEL
+  - UNEXPECTED_MULTI_WRITE
+  - UNEXPECTED_RANGE_OPERATOR
+  - UNEXPECTED_SAFE_NAVIGATION
+  - UNEXPECTED_TOKEN_CLOSE_CONTEXT
+  - UNEXPECTED_TOKEN_IGNORE
+  - UNTIL_TERM
+  - VOID_EXPRESSION
+  - WHILE_TERM
+  - WRITE_TARGET_IN_METHOD
+  - WRITE_TARGET_READONLY
+  - WRITE_TARGET_UNEXPECTED
+  - XSTRING_TERM
+warnings:
+  - AMBIGUOUS_BINARY_OPERATOR
+  - AMBIGUOUS_FIRST_ARGUMENT_MINUS
+  - AMBIGUOUS_FIRST_ARGUMENT_PLUS
+  - AMBIGUOUS_PREFIX_AMPERSAND
+  - AMBIGUOUS_PREFIX_STAR
+  - AMBIGUOUS_PREFIX_STAR_STAR
+  - AMBIGUOUS_SLASH
+  - COMPARISON_AFTER_COMPARISON
+  - DOT_DOT_DOT_EOL
+  - EQUAL_IN_CONDITIONAL
+  - EQUAL_IN_CONDITIONAL_3_3
+  - END_IN_METHOD
+  - DUPLICATED_HASH_KEY
+  - DUPLICATED_WHEN_CLAUSE
+  - FLOAT_OUT_OF_RANGE
+  - IGNORED_FROZEN_STRING_LITERAL
+  - INDENTATION_MISMATCH
+  - INTEGER_IN_FLIP_FLOP
+  - INVALID_CHARACTER
+  - INVALID_MAGIC_COMMENT_VALUE
+  - INVALID_NUMBERED_REFERENCE
+  - KEYWORD_EOL
+  - LITERAL_IN_CONDITION_DEFAULT
+  - LITERAL_IN_CONDITION_VERBOSE
+  - SHAREABLE_CONSTANT_VALUE_LINE
+  - SHEBANG_CARRIAGE_RETURN
+  - UNEXPECTED_CARRIAGE_RETURN
+  - UNREACHABLE_STATEMENT
+  - UNUSED_LOCAL_VARIABLE
+  - VOID_STATEMENT
 tokens:
   - name: EOF
     value: 1
@@ -331,8 +652,16 @@ tokens:
 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 arguments contain 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:
@@ -368,6 +697,13 @@ flags:
       - 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
@@ -383,6 +719,11 @@ flags:
       - 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
@@ -413,6 +754,15 @@ flags:
       - 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
@@ -420,7 +770,9 @@ flags:
       - name: FORCED_BINARY_ENCODING
         comment: "internal bytes forced the encoding to binary"
       - name: FROZEN
-        comment: "frozen by virtue of a `frozen_string_literal` comment"
+        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:
@@ -436,10 +788,35 @@ nodes:
     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.
 
@@ -449,10 +826,45 @@ nodes:
     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.
 
@@ -462,10 +874,27 @@ nodes:
     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.
 
@@ -475,6 +904,7 @@ nodes:
     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).
 
@@ -485,8 +915,9 @@ nodes:
               ^
       - name: right
         type: node
+        kind: Node
         comment: |
-          Represents the right 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).
+          Represents the right side of the expression.
 
               left && right
                       ^^^^^
@@ -506,28 +937,46 @@ nodes:
           left and right
           ^^^^^^^^^^^^^^
   - name: ArgumentsNode
+    flags: ArgumentsNodeFlags
     fields:
-      - name: flags
-        type: flags
-        kind: ArgumentsNodeFlags
       - 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: flags
-        type: flags
-        kind: ArrayNodeFlags
       - 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.
 
@@ -537,16 +986,47 @@ nodes:
     fields:
       - name: constant
         type: node?
+        kind:
+          - ConstantReadNode
+          - ConstantPathNode
       - 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.
 
@@ -556,8 +1036,8 @@ nodes:
           foo in [1, 2]
           ^^^^^^^^^^^^^
 
-          foo in *1
-          ^^^^^^^^^
+          foo in *bar
+          ^^^^^^^^^^^
 
           foo in Bar[]
           ^^^^^^^^^^^^
@@ -568,6 +1048,7 @@ nodes:
     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).
 
@@ -581,6 +1062,7 @@ nodes:
                 ^^^^^^^^^^
       - 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).
 
@@ -605,6 +1087,7 @@ nodes:
     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.
 
@@ -641,20 +1124,50 @@ nodes:
     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.
@@ -667,20 +1180,34 @@ nodes:
     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 block method arguments.
+      Represents a block argument using `&`.
 
           bar(&args)
           ^^^^^^^^^^
   - name: BlockLocalVariableNode
+    flags: ParameterFlags
     fields:
-      - name: flags
-        type: flags
-        kind: ParameterFlags
       - name: name
         type: constant
+        comment: |
+          The name of the block local variable.
+
+              a { |; b| } # name `:b`
+                     ^
     comment: |
       Represents a block local variable.
 
@@ -690,32 +1217,83 @@ nodes:
     fields:
       - name: locals
         type: constant[]
+        comment: |
+          The local variables declared in the block.
+
+              [1, 2, 3].each { |i| puts x } # locals: [:i]
+                                ^
       - name: parameters
         type: node?
+        kind:
+          - BlockParametersNode
+          - NumberedParametersNode
+          - ItParametersNode
+        comment: |
+          The parameters of the block.
+
+              [1, 2, 3].each { |i| puts x }
+                               ^^^
+              [1, 2, 3].each { puts _1 }
+                             ^^^^^^^^^^^
+              [1, 2, 3].each { puts it }
+                             ^^^^^^^^^^^
       - name: body
         type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
+        comment: |
+          The body of the block.
+
+              [1, 2, 3].each { |i| puts x }
+                                   ^^^^^^
       - name: opening_loc
         type: location
+        comment: |
+          Represents the location of the opening `|`.
+
+              [1, 2, 3].each { |i| puts x }
+                               ^
       - name: closing_loc
         type: location
+        comment: |
+          Represents the location of the closing `|`.
+
+              [1, 2, 3].each { |i| puts x }
+                                 ^
     comment: |
       Represents a block of ruby code.
 
           [1, 2, 3].each { |i| puts x }
                          ^^^^^^^^^^^^^^
   - name: BlockParameterNode
+    flags: ParameterFlags
     fields:
-      - name: flags
-        type: flags
-        kind: ParameterFlags
       - 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 to a method, block, or lambda definition.
+      Represents a block parameter of a method, block, or lambda definition.
 
           def a(&b)
                 ^^
@@ -725,12 +1303,49 @@ nodes:
       - 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.
 
@@ -745,44 +1360,88 @@ nodes:
       - 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: flags
-        type: flags
-        kind: CallNodeFlags
       - 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: flags
-        type: flags
-        kind: CallNodeFlags
       - 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).
 
@@ -796,19 +1455,59 @@ nodes:
               ^^^
       - name: call_operator_loc
         type: location?
+        comment: |
+          Represents the location of the call operator.
+
+              foo.bar
+                 ^
+
+              foo&.bar
+                 ^^
       - name: name
         type: constant
+        comment: |
+          Represents the name of the method being called.
+
+              foo.bar # name `:foo`
+              ^^^
       - name: message_loc
         type: location?
+        comment: |
+          Represents the location of the message.
+
+              foo.bar
+                  ^^^
       - name: opening_loc
         type: location?
+        comment: |
+          Represents the location of the left parenthesis.
+              foo(bar)
+                 ^
       - name: arguments
         type: node?
         kind: ArgumentsNode
+        comment: |
+          Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+
+              foo(bar)
+                  ^^^
       - name: closing_loc
         type: location?
+        comment: |
+          Represents the location of the right parenthesis.
+
+              foo(bar)
+                     ^
       - name: block
         type: node?
+        kind:
+          - BlockNode
+          - BlockArgumentNode
+        comment: |
+          Represents the block that is being passed to the method.
+
+              foo { |a| a }
+                  ^^^^^^^^^
     comment: |
       Represents a method call, in all of the various forms that can take.
 
@@ -830,68 +1529,162 @@ nodes:
           foo&.bar
           ^^^^^^^^
   - name: CallOperatorWriteNode
+    flags: CallNodeFlags
     fields:
-      - name: flags
-        type: flags
-        kind: CallNodeFlags
       - 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
-      - name: operator
+        comment: |
+          Represents the name of the method being written to.
+
+              foo.bar += value # write_name `:bar=`
+                  ^^^
+      - name: binary_operator
         type: constant
-      - name: operator_loc
+        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: flags
-        type: flags
-        kind: CallNodeFlags
       - 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: flags
-        type: flags
-        kind: CallNodeFlags
       - 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.
 
@@ -909,10 +1702,27 @@ nodes:
     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.
 
@@ -922,15 +1732,42 @@ nodes:
     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[]
-      - name: consequent
+        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.
 
@@ -942,15 +1779,42 @@ nodes:
     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[]
-      - name: consequent
+        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.
 
@@ -966,12 +1830,20 @@ nodes:
         type: location
       - name: constant_path
         type: node
+        kind:
+          - ConstantReadNode
+          - ConstantPathNode
+          - on error: CallNode # class 0.X end
       - name: inheritance_operator_loc
         type: location?
       - name: superclass
         type: node?
+        kind: non-void expression
       - name: body
         type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
       - name: end_keyword_loc
         type: location
       - name: name
@@ -985,12 +1857,33 @@ nodes:
     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.
 
@@ -1002,11 +1895,12 @@ nodes:
         type: constant
       - name: name_loc
         type: location
-      - name: operator_loc
+      - name: binary_operator_loc
         type: location
       - name: value
         type: node
-      - name: operator
+        kind: non-void expression
+      - name: binary_operator
         type: constant
     comment: |
       Represents assigning to a class variable using an operator that isn't `=`.
@@ -1023,6 +1917,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `||=` operator for assignment to a class variable.
 
@@ -1056,12 +1951,37 @@ nodes:
     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?
+        type: location
+        comment: |
+          The location of the `=` operator.
+
+              @@foo = :bar
+                    ^
     comment: |
       Represents writing to a class variable.
 
@@ -1077,6 +1997,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `&&=` operator for assignment to a constant.
 
@@ -1088,11 +2009,12 @@ nodes:
         type: constant
       - name: name_loc
         type: location
-      - name: operator_loc
+      - name: binary_operator_loc
         type: location
       - name: value
         type: node
-      - name: operator
+        kind: non-void expression
+      - name: binary_operator
         type: constant
     comment: |
       Represents assigning to a constant using an operator that isn't `=`.
@@ -1109,6 +2031,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `||=` operator for assignment to a constant.
 
@@ -1123,6 +2046,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `&&=` operator for assignment to a constant path.
 
@@ -1132,10 +2056,41 @@ nodes:
     fields:
       - name: parent
         type: node?
-      - name: child
-        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.
 
@@ -1146,11 +2101,12 @@ nodes:
       - name: target
         type: node
         kind: ConstantPathNode
-      - name: operator_loc
+      - name: binary_operator_loc
         type: location
       - name: value
         type: node
-      - name: operator
+        kind: non-void expression
+      - name: binary_operator
         type: constant
     comment: |
       Represents assigning to a constant path using an operator that isn't `=`.
@@ -1166,6 +2122,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `||=` operator for assignment to a constant path.
 
@@ -1175,10 +2132,13 @@ nodes:
     fields:
       - name: parent
         type: node?
-      - name: child
-        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.
 
@@ -1189,10 +2149,29 @@ nodes:
       - 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.
 
@@ -1232,12 +2211,37 @@ nodes:
     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.
 
@@ -1251,11 +2255,15 @@ nodes:
         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
@@ -1282,6 +2290,7 @@ nodes:
         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
@@ -1325,6 +2334,12 @@ nodes:
         type: location
       - name: variable
         type: node
+        kind:
+          - InstanceVariableReadNode
+          - ClassVariableReadNode
+          - GlobalVariableReadNode
+          - BackReferenceReadNode
+          - NumberedReferenceReadNode
     comment: |
       Represents an interpolated variable.
 
@@ -1358,12 +2373,20 @@ nodes:
     fields:
       - name: constant
         type: node?
+        kind:
+          - ConstantReadNode
+          - ConstantPathNode
       - name: left
         type: node
+        kind: SplatNode
       - name: requireds
         type: node[]
+        kind: pattern expression
       - name: right
         type: node
+        kind:
+          - SplatNode
+          - on error: MissingNode
       - name: opening_loc
         type: location?
       - name: closing_loc
@@ -1380,14 +2403,14 @@ nodes:
           foo in Foo(*bar, baz, *qux)
                  ^^^^^^^^^^^^^^^^^^^^
   - name: FlipFlopNode
+    flags: RangeFlags
     fields:
-      - name: flags
-        type: flags
-        kind: RangeFlags
       - name: left
         type: node?
+        kind: non-void expression
       - name: right
         type: node?
+        kind: non-void expression
       - name: operator_loc
         type: location
     comment: |
@@ -1396,6 +2419,10 @@ nodes:
           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.
 
@@ -1405,19 +2432,70 @@ nodes:
     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.
 
@@ -1458,6 +2536,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `&&=` operator for assignment to a global variable.
 
@@ -1469,11 +2548,12 @@ nodes:
         type: constant
       - name: name_loc
         type: location
-      - name: operator_loc
+      - name: binary_operator_loc
         type: location
       - name: value
         type: node
-      - name: operator
+        kind: non-void expression
+      - name: binary_operator
         type: constant
     comment: |
       Represents assigning to a global variable using an operator that isn't `=`.
@@ -1490,6 +2570,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `||=` operator for assignment to a global variable.
 
@@ -1523,12 +2604,37 @@ nodes:
     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.
 
@@ -1545,6 +2651,9 @@ nodes:
               ^
       - name: elements
         type: node[]
+        kind:
+          - AssocNode
+          - AssocSplatNode
         comment: |
           The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
 
@@ -1569,10 +2678,17 @@ nodes:
     fields:
       - name: constant
         type: node?
+        kind:
+          - ConstantReadNode
+          - ConstantPathNode
       - name: elements
         type: node[]
+        kind: AssocNode
       - name: rest
         type: node?
+        kind:
+          - AssocSplatNode
+          - NoKeywordsParameterNode
       - name: opening_loc
         type: location?
       - name: closing_loc
@@ -1589,30 +2705,99 @@ nodes:
     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
-      - name: consequent
+        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.
+      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.
 
@@ -1622,6 +2807,11 @@ nodes:
     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.
 
@@ -1652,6 +2842,7 @@ nodes:
     fields:
       - name: pattern
         type: node
+        kind: pattern expression
       - name: statements
         type: node?
         kind: StatementsNode
@@ -1665,12 +2856,11 @@ nodes:
           case a; in b then c end
                   ^^^^^^^^^^^
   - name: IndexAndWriteNode
+    flags: CallNodeFlags
     fields:
-      - name: flags
-        type: flags
-        kind: CallNodeFlags
       - name: receiver
         type: node?
+        kind: non-void expression
       - name: call_operator_loc
         type: location?
       - name: opening_loc
@@ -1682,22 +2872,23 @@ nodes:
         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: flags
-        type: flags
-        kind: CallNodeFlags
       - name: receiver
         type: node?
+        kind: non-void expression
       - name: call_operator_loc
         type: location?
       - name: opening_loc
@@ -1709,24 +2900,25 @@ nodes:
         type: location
       - name: block
         type: node?
-      - name: operator
+        kind: BlockArgumentNode # foo[&b] += value, only valid on Ruby < 3.4
+      - name: binary_operator
         type: constant
-      - name: operator_loc
+      - 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: flags
-        type: flags
-        kind: CallNodeFlags
       - name: receiver
         type: node?
+        kind: non-void expression
       - name: call_operator_loc
         type: location?
       - name: opening_loc
@@ -1738,22 +2930,23 @@ nodes:
         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: flags
-        type: flags
-        kind: CallNodeFlags
       - name: receiver
         type: node
+        kind: non-void expression
       - name: opening_loc
         type: location
       - name: arguments
@@ -1763,6 +2956,7 @@ nodes:
         type: location
       - name: block
         type: node?
+        kind: BlockArgumentNode # foo[&b], = 1, only valid on Ruby < 3.4
     comment: |
       Represents assigning to an index.
 
@@ -1786,6 +2980,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `&&=` operator for assignment to an instance variable.
 
@@ -1797,11 +2992,12 @@ nodes:
         type: constant
       - name: name_loc
         type: location
-      - name: operator_loc
+      - name: binary_operator_loc
         type: location
       - name: value
         type: node
-      - name: operator
+        kind: non-void expression
+      - name: binary_operator
         type: constant
     comment: |
       Represents assigning to an instance variable using an operator that isn't `=`.
@@ -1818,6 +3014,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents the use of the `||=` operator for assignment to an instance variable.
 
@@ -1851,36 +3048,64 @@ nodes:
     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: flags
-        type: flags
-        kind: IntegerBaseFlags
+      - 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: flags
-        type: flags
-        kind: RegularExpressionFlags
       - name: opening_loc
         type: location
       - name: parts
         type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
       - name: closing_loc
         type: location
     newline: parts
@@ -1890,14 +3115,16 @@ nodes:
           if /foo #{bar} baz/ then end
              ^^^^^^^^^^^^^^^^
   - name: InterpolatedRegularExpressionNode
+    flags: RegularExpressionFlags
     fields:
-      - name: flags
-        type: flags
-        kind: RegularExpressionFlags
       - name: opening_loc
         type: location
       - name: parts
         type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
       - name: closing_loc
         type: location
     newline: parts
@@ -1907,11 +3134,18 @@ nodes:
           /foo #{bar} baz/
           ^^^^^^^^^^^^^^^^
   - name: InterpolatedStringNode
+    flags: InterpolatedStringNodeFlags
     fields:
       - name: opening_loc
         type: location?
       - name: parts
         type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
+          - InterpolatedStringNode # `"a" "#{b}"`
+          - on error: XStringNode # `<<`FOO` "bar"
       - name: closing_loc
         type: location?
     newline: parts
@@ -1926,6 +3160,10 @@ nodes:
         type: location?
       - name: parts
         type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
       - name: closing_loc
         type: location?
     newline: parts
@@ -1940,6 +3178,10 @@ nodes:
         type: location
       - name: parts
         type: node[]
+        kind:
+          - StringNode
+          - EmbeddedStatementsNode
+          - EmbeddedVariableNode
       - name: closing_loc
         type: location
     newline: parts
@@ -1948,23 +3190,34 @@ nodes:
 
           `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: flags
-        type: flags
-        kind: KeywordHashNodeFlags
       - 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: flags
-        type: flags
-        kind: ParameterFlags
       - name: name
         type: constant?
       - name: name_loc
@@ -1989,8 +3242,15 @@ nodes:
         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).
 
@@ -2004,6 +3264,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
       - name: name
         type: constant
       - name: depth
@@ -2017,13 +3278,14 @@ nodes:
     fields:
       - name: name_loc
         type: location
-      - name: operator_loc
+      - name: binary_operator_loc
         type: location
       - name: value
         type: node
+        kind: non-void expression
       - name: name
         type: constant
-      - name: operator
+      - name: binary_operator
         type: constant
       - name: depth
         type: uint32
@@ -2040,6 +3302,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
       - name: name
         type: constant
       - name: depth
@@ -2064,10 +3327,6 @@ nodes:
 
               _1     # name `:_1`
 
-          Finally, for the default `it` block parameter, the name is `0it`. This is to distinguish it from an `it` local variable that is explicitly declared.
-
-              it     # name `:0it`
-
       - name: depth
         type: uint32
         comment: |
@@ -2098,24 +3357,59 @@ nodes:
     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: flags
-        type: flags
-        kind: RegularExpressionFlags
       - name: opening_loc
         type: location
       - name: content_loc
@@ -2133,8 +3427,10 @@ nodes:
     fields:
       - name: value
         type: node
+        kind: non-void expression
       - name: pattern
         type: node
+        kind: pattern expression
       - name: operator_loc
         type: location
     comment: |
@@ -2146,8 +3442,10 @@ nodes:
     fields:
       - name: value
         type: node
+        kind: non-void expression
       - name: pattern
         type: node
+        kind: pattern expression
       - name: operator_loc
         type: location
     comment: |
@@ -2162,6 +3460,7 @@ nodes:
         kind: CallNode
       - name: targets
         type: node[]
+        kind: LocalVariableTargetNode
     comment: |
       Represents writing local variables using a regular expression match with named capture groups.
 
@@ -2178,8 +3477,15 @@ nodes:
         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
@@ -2193,35 +3499,187 @@ nodes:
     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.
 
@@ -2271,29 +3729,28 @@ nodes:
       - name: number
         type: uint32
         comment: |
-          The (1-indexed, from the left) number of the capture group. Numbered references that would overflow a `uint32`  result in a `number` of exactly `2**32 - 1`.
+          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 `4294967295`
+              $4294967296 # number `0`
     comment: |
       Represents reading a numbered reference to a capture in the previous match.
 
           $1
           ^^
   - name: OptionalKeywordParameterNode
+    flags: ParameterFlags
     fields:
-      - name: flags
-        type: flags
-        kind: ParameterFlags
       - 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.
 
@@ -2301,10 +3758,8 @@ nodes:
                 ^^^^
           end
   - name: OptionalParameterNode
+    flags: ParameterFlags
     fields:
-      - name: flags
-        type: flags
-        kind: ParameterFlags
       - name: name
         type: constant
       - name: name_loc
@@ -2313,6 +3768,7 @@ nodes:
         type: location
       - name: value
         type: node
+        kind: non-void expression
     comment: |
       Represents an optional parameter to a method, block, or lambda definition.
 
@@ -2323,6 +3779,7 @@ nodes:
     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).
 
@@ -2333,8 +3790,9 @@ nodes:
               ^
       - name: right
         type: node
+        kind: Node
         comment: |
-          Represents the right 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).
+          Represents the right side of the expression.
 
               left || right
                       ^^^^^
@@ -2357,16 +3815,38 @@ nodes:
     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
@@ -2377,9 +3857,11 @@ nodes:
                 ^^^^^^^
           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
@@ -2394,6 +3876,7 @@ nodes:
     fields:
       - name: expression
         type: node
+        kind: non-void expression
       - name: operator_loc
         type: location
       - name: lparen_loc
@@ -2409,6 +3892,15 @@ nodes:
     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
       - name: operator_loc
         type: location
     comment: |
@@ -2457,12 +3949,11 @@ nodes:
         kind: StatementsNode
     comment: The top level node of any parse tree.
   - name: RangeNode
+    flags: RangeFlags
     fields:
-      - name: flags
-        type: flags
-        kind: RangeFlags
       - 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).
 
@@ -2473,6 +3964,7 @@ nodes:
               ^^^^^
       - 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).
 
@@ -2495,9 +3987,20 @@ nodes:
           c if a =~ /left/ ... b =~ /right/
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   - name: RationalNode
+    flags: IntegerBaseFlags
     fields:
-      - name: numeric
-        type: node
+      - 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.
 
@@ -2510,10 +4013,8 @@ nodes:
           redo
           ^^^^
   - name: RegularExpressionNode
+    flags: RegularExpressionFlags
     fields:
-      - name: flags
-        type: flags
-        kind: RegularExpressionFlags
       - name: opening_loc
         type: location
       - name: content_loc
@@ -2528,10 +4029,8 @@ nodes:
           /foo/i
           ^^^^^^
   - name: RequiredKeywordParameterNode
+    flags: ParameterFlags
     fields:
-      - name: flags
-        type: flags
-        kind: ParameterFlags
       - name: name
         type: constant
       - name: name_loc
@@ -2543,10 +4042,8 @@ nodes:
                 ^^
           end
   - name: RequiredParameterNode
+    flags: ParameterFlags
     fields:
-      - name: flags
-        type: flags
-        kind: ParameterFlags
       - name: name
         type: constant
     comment: |
@@ -2559,10 +4056,12 @@ nodes:
     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.
@@ -2575,14 +4074,29 @@ nodes:
         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: consequent
+      - name: subsequent
         type: node?
         kind: RescueNode
     comment: |
@@ -2594,12 +4108,10 @@ nodes:
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
           end
 
-      `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `exception` field.
+      `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field.
   - name: RestParameterNode
+    flags: ParameterFlags
     fields:
-      - name: flags
-        type: flags
-        kind: ParameterFlags
       - name: name
         type: constant?
       - name: name_loc
@@ -2636,6 +4148,27 @@ nodes:
 
           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
@@ -2646,8 +4179,12 @@ nodes:
         type: location
       - name: expression
         type: node
+        kind: non-void expression
       - name: body
         type: node?
+        kind:
+          - StatementsNode
+          - BeginNode
       - name: end_keyword_loc
         type: location
     comment: |
@@ -2662,9 +4199,11 @@ nodes:
           __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.
 
@@ -2682,6 +4221,7 @@ nodes:
         type: location
       - name: expression
         type: node?
+        kind: non-void expression
     comment: |
       Represents the use of the splat operator.
 
@@ -2691,16 +4231,15 @@ nodes:
     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: flags
-        type: flags
-        kind: StringFlags
       - name: opening_loc
         type: location?
       - name: content_loc
@@ -2733,6 +4272,9 @@ nodes:
         type: location?
       - name: block
         type: node?
+        kind:
+          - BlockNode
+          - BlockArgumentNode
     comment: |
       Represents the use of the `super` keyword with parentheses or arguments.
 
@@ -2742,10 +4284,8 @@ nodes:
           super foo, bar
           ^^^^^^^^^^^^^^
   - name: SymbolNode
+    flags: SymbolFlags
     fields:
-      - name: flags
-        type: flags
-        kind: SymbolFlags
       - name: opening_loc
         type: location?
       - name: value_loc
@@ -2772,6 +4312,9 @@ nodes:
     fields:
       - name: names
         type: node[]
+        kind:
+          - SymbolNode
+          - InterpolatedSymbolNode
       - name: keyword_loc
         type: location
     comment: |
@@ -2783,18 +4326,56 @@ nodes:
     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
-      - name: consequent
+        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.
@@ -2805,16 +4386,17 @@ nodes:
           unless foo then bar end
           ^^^^^^^^^^^^^^^^^^^^^^^
   - name: UntilNode
+    flags: LoopFlags
     fields:
-      - name: flags
-        type: flags
-        kind: LoopFlags
       - 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
@@ -2833,6 +4415,9 @@ nodes:
         type: location
       - name: conditions
         type: node[]
+        kind: non-void expression
+      - name: then_keyword_loc
+        type: location?
       - name: statements
         type: node?
         kind: StatementsNode
@@ -2844,16 +4429,17 @@ nodes:
           ^^^^^^^^^
           end
   - name: WhileNode
+    flags: LoopFlags
     fields:
-      - name: flags
-        type: flags
-        kind: LoopFlags
       - 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
@@ -2867,10 +4453,8 @@ nodes:
           while foo do bar end
           ^^^^^^^^^^^^^^^^^^^^
   - name: XStringNode
+    flags: EncodingFlags
     fields:
-      - name: flags
-        type: flags
-        kind: EncodingFlags
       - name: opening_loc
         type: location
       - name: content_loc