prism 1.4.0 → 1.8.0

data/lib/prism/node.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 =begin
+--
 This file is generated by the templates/template.rb script and should not be
 modified manually. See templates/lib/prism/node.rb.erb
 if you are looking to modify the template
+++
 =end
 
 module Prism
@@ -195,7 +198,7 @@ module Prism
       while (node = queue.shift)
         result << node
 
-        node.compact_child_nodes.each do |child_node|
+        node.each_child_node do |child_node|
           child_location = child_node.location
 
           start_line = child_location.start_line
@@ -267,6 +270,13 @@ module Prism
 
     alias deconstruct child_nodes
 
+    # With a block given, yields each child node. Without a block, returns
+    # an enumerator that contains each child node. Excludes any `nil`s in
+    # the place of optional nodes that were not present.
+    def each_child_node
+      raise NoMethodError, "undefined method `each_child_node' for #{inspect}"
+    end
+
     # Returns an array of child nodes, excluding any `nil`s in the place of
     # optional nodes that were not present.
     def compact_child_nodes
@@ -330,11 +340,19 @@ module Prism
       visitor.visit_alias_global_variable_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [new_name, old_name]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield new_name
+      yield old_name
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [new_name, old_name]
@@ -350,7 +368,7 @@ module Prism
       AliasGlobalVariableNode.new(source, node_id, location, flags, new_name, old_name, keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, keyword_loc: Location }
@@ -437,11 +455,19 @@ module Prism
       visitor.visit_alias_method_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [new_name, old_name]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield new_name
+      yield old_name
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [new_name, old_name]
@@ -457,7 +483,7 @@ module Prism
       AliasMethodNode.new(source, node_id, location, flags, new_name, old_name, keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: SymbolNode | InterpolatedSymbolNode, old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, keyword_loc: Location }
@@ -556,11 +582,19 @@ module Prism
       visitor.visit_alternation_pattern_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [left, right]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield left
+      yield right
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [left, right]
@@ -576,7 +610,7 @@ module Prism
       AlternationPatternNode.new(source, node_id, location, flags, left, right, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
@@ -663,11 +697,19 @@ module Prism
       visitor.visit_and_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [left, right]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield left
+      yield right
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [left, right]
@@ -683,7 +725,7 @@ module Prism
       AndNode.new(source, node_id, location, flags, left, right, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
@@ -774,11 +816,18 @@ module Prism
       visitor.visit_arguments_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*arguments]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      arguments.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*arguments]
@@ -794,7 +843,7 @@ module Prism
       ArgumentsNode.new(source, node_id, location, flags, arguments)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: Array[Prism::node] }
@@ -879,11 +928,18 @@ module Prism
       visitor.visit_array_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*elements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      elements.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*elements]
@@ -899,7 +955,7 @@ module Prism
       ArrayNode.new(source, node_id, location, flags, elements, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
@@ -1036,11 +1092,21 @@ module Prism
       visitor.visit_array_pattern_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [constant, *requireds, rest, *posts]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield constant if constant
+      requireds.each { |node| yield node }
+      yield rest if rest
+      posts.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -1056,20 +1122,29 @@ module Prism
       [*constant, *requireds, *rest, *posts, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode
+    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode
     def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, requireds: self.requireds, rest: self.rest, posts: self.posts, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
       ArrayPatternNode.new(source, node_id, location, flags, constant, requireds, rest, posts, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
     def deconstruct_keys(keys)
       { node_id: node_id, location: location, constant: constant, requireds: requireds, rest: rest, posts: posts, opening_loc: opening_loc, closing_loc: closing_loc }
     end
 
-    # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
+    # Represents the optional constant preceding the Array
+    #
+    #     foo in Bar[]
+    #            ^^^
+    #
+    #     foo in Bar[1, 2, 3]
+    #            ^^^
+    #
+    #     foo in Bar::Baz[1, 2, 3]
+    #            ^^^^^^^^
     attr_reader :constant
 
     # Represents the required elements of the array pattern.
@@ -1195,11 +1270,19 @@ module Prism
       visitor.visit_assoc_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [key, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield key
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [key, value]
@@ -1215,7 +1298,7 @@ module Prism
       AssocNode.new(source, node_id, location, flags, key, value, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, key: Prism::node, value: Prism::node, operator_loc: Location? }
@@ -1316,11 +1399,18 @@ module Prism
       visitor.visit_assoc_splat_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value if value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -1338,7 +1428,7 @@ module Prism
       AssocSplatNode.new(source, node_id, location, flags, value, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node?, operator_loc: Location }
@@ -1416,11 +1506,17 @@ module Prism
       visitor.visit_back_reference_read_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -1436,7 +1532,7 @@ module Prism
       BackReferenceReadNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -1500,11 +1596,21 @@ module Prism
       visitor.visit_begin_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [statements, rescue_clause, else_clause, ensure_clause]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield statements if statements
+      yield rescue_clause if rescue_clause
+      yield else_clause if else_clause
+      yield ensure_clause if ensure_clause
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -1525,7 +1631,7 @@ module Prism
       BeginNode.new(source, node_id, location, flags, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location? }
@@ -1659,11 +1765,18 @@ module Prism
       visitor.visit_block_argument_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [expression]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield expression if expression
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -1681,7 +1794,7 @@ module Prism
       BlockArgumentNode.new(source, node_id, location, flags, expression, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node?, operator_loc: Location }
@@ -1759,11 +1872,17 @@ module Prism
       visitor.visit_block_local_variable_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -1779,7 +1898,7 @@ module Prism
       BlockLocalVariableNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -1845,11 +1964,19 @@ module Prism
       visitor.visit_block_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [parameters, body]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield parameters if parameters
+      yield body if body
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -1868,7 +1995,7 @@ module Prism
       BlockNode.new(source, node_id, location, flags, locals, parameters, body, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil, opening_loc: Location, closing_loc: Location }
@@ -1990,11 +2117,17 @@ module Prism
       visitor.visit_block_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -2010,7 +2143,7 @@ module Prism
       BlockParameterNode.new(source, node_id, location, flags, name, name_loc, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
@@ -2126,11 +2259,19 @@ module Prism
       visitor.visit_block_parameters_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [parameters, *locals]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield parameters if parameters
+      locals.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -2149,7 +2290,7 @@ module Prism
       BlockParametersNode.new(source, node_id, location, flags, parameters, locals, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location? }
@@ -2286,11 +2427,18 @@ module Prism
       visitor.visit_break_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [arguments]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield arguments if arguments
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -2308,7 +2456,7 @@ module Prism
       BreakNode.new(source, node_id, location, flags, arguments, keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
@@ -2392,11 +2540,19 @@ module Prism
       visitor.visit_call_and_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver if receiver
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -2415,7 +2571,7 @@ module Prism
       CallAndWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
@@ -2593,7 +2749,7 @@ module Prism
   #     ^^^^^^^^
   class CallNode < Node
     # Initialize a new CallNode node.
-    def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block)
+    def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, equal_loc, block)
       @source = source
       @node_id = node_id
       @location = location
@@ -2605,6 +2761,7 @@ module Prism
       @opening_loc = opening_loc
       @arguments = arguments
       @closing_loc = closing_loc
+      @equal_loc = equal_loc
       @block = block
     end
 
@@ -2613,11 +2770,20 @@ module Prism
       visitor.visit_call_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, arguments, block]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver if receiver
+      yield arguments if arguments
+      yield block if block
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -2629,20 +2795,20 @@ module Prism
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, *block] #: Array[Prism::node | Location]
+      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, *equal_loc, *block] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
-    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block)
-      CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block)
+    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?equal_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
+    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, equal_loc: self.equal_loc, block: self.block)
+      CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, equal_loc, block)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, equal_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
     def deconstruct_keys(keys)
-      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block }
+      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, equal_loc: equal_loc, block: block }
     end
 
     # def safe_navigation?: () -> bool
@@ -2779,6 +2945,31 @@ module Prism
       repository.enter(node_id, :closing_loc) unless @closing_loc.nil?
     end
 
+    # Represents the location of the equal sign, in the case that this is an attribute write.
+    #
+    #     foo.bar = value
+    #             ^
+    #
+    #     foo[bar] = value
+    #              ^
+    def equal_loc
+      location = @equal_loc
+      case location
+      when nil
+        nil
+      when Location
+        location
+      else
+        @equal_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
+      end
+    end
+
+    # Save the equal_loc location using the given saved source so that
+    # it can be retrieved later.
+    def save_equal_loc(repository)
+      repository.enter(node_id, :equal_loc) unless @equal_loc.nil?
+    end
+
     # Represents the block that is being passed to the method.
     #
     #     foo { |a| a }
@@ -2805,6 +2996,11 @@ module Prism
       closing_loc&.slice
     end
 
+    # def equal: () -> String?
+    def equal
+      equal_loc&.slice
+    end
+
     # def inspect -> String
     def inspect
       InspectVisitor.compose(self)
@@ -2832,6 +3028,7 @@ module Prism
         (opening_loc.nil? == other.opening_loc.nil?) &&
         (arguments === other.arguments) &&
         (closing_loc.nil? == other.closing_loc.nil?) &&
+        (equal_loc.nil? == other.equal_loc.nil?) &&
         (block === other.block)
     end
   end
@@ -2862,11 +3059,19 @@ module Prism
       visitor.visit_call_operator_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver if receiver
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -2885,7 +3090,7 @@ module Prism
       CallOperatorWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
@@ -3069,11 +3274,19 @@ module Prism
       visitor.visit_call_or_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver if receiver
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -3092,7 +3305,7 @@ module Prism
       CallOrWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
@@ -3279,11 +3492,18 @@ module Prism
       visitor.visit_call_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [receiver]
@@ -3299,7 +3519,7 @@ module Prism
       CallTargetNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location }
@@ -3429,11 +3649,19 @@ module Prism
       visitor.visit_capture_pattern_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value, target]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+      yield target
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value, target]
@@ -3449,7 +3677,7 @@ module Prism
       CapturePatternNode.new(source, node_id, location, flags, value, target, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: LocalVariableTargetNode, operator_loc: Location }
@@ -3540,11 +3768,20 @@ module Prism
       visitor.visit_case_match_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [predicate, *conditions, else_clause]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield predicate if predicate
+      conditions.each { |node| yield node }
+      yield else_clause if else_clause
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -3564,7 +3801,7 @@ module Prism
       CaseMatchNode.new(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[InNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
@@ -3685,11 +3922,20 @@ module Prism
       visitor.visit_case_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [predicate, *conditions, else_clause]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield predicate if predicate
+      conditions.each { |node| yield node }
+      yield else_clause if else_clause
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -3709,7 +3955,7 @@ module Prism
       CaseNode.new(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[WhenNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
@@ -3720,7 +3966,7 @@ module Prism
     # 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
-    #     ^^^^
+    #          ^^^^
     attr_reader :predicate
 
     # Represents the conditions of the case statement.
@@ -3831,11 +4077,20 @@ module Prism
       visitor.visit_class_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [constant_path, superclass, body]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield constant_path
+      yield superclass if superclass
+      yield body if body
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -3855,7 +4110,7 @@ module Prism
       ClassNode.new(source, node_id, location, flags, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | CallNode, inheritance_operator_loc: Location?, superclass: Prism::node?, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
@@ -3866,7 +4121,10 @@ module Prism
     # attr_reader locals: Array[Symbol]
     attr_reader :locals
 
-    # attr_reader class_keyword_loc: Location
+    # Represents the location of the `class` keyword.
+    #
+    #     class Foo end
+    #     ^^^^^
     def class_keyword_loc
       location = @class_keyword_loc
       return location if location.is_a?(Location)
@@ -3882,7 +4140,10 @@ module Prism
     # attr_reader constant_path: ConstantReadNode | ConstantPathNode | CallNode
     attr_reader :constant_path
 
-    # attr_reader inheritance_operator_loc: Location?
+    # Represents the location of the `<` operator.
+    #
+    #     class Foo < Bar
+    #               ^
     def inheritance_operator_loc
       location = @inheritance_operator_loc
       case location
@@ -3901,13 +4162,23 @@ module Prism
       repository.enter(node_id, :inheritance_operator_loc) unless @inheritance_operator_loc.nil?
     end
 
-    # attr_reader superclass: Prism::node?
+    # Represents the superclass of the class.
+    #
+    #     class Foo < Bar
+    #                 ^^^
     attr_reader :superclass
 
-    # attr_reader body: StatementsNode | BeginNode | nil
+    # Represents the body of the class.
+    #
+    #     class Foo
+    #       foo
+    #       ^^^
     attr_reader :body
 
-    # attr_reader end_keyword_loc: Location
+    # Represents the location of the `end` keyword.
+    #
+    #     class Foo end
+    #               ^^^
     def end_keyword_loc
       location = @end_keyword_loc
       return location if location.is_a?(Location)
@@ -3920,7 +4191,9 @@ module Prism
       repository.enter(node_id, :end_keyword_loc)
     end
 
-    # attr_reader name: Symbol
+    # The name of the class.
+    #
+    #     class Foo end # name `:Foo`
     attr_reader :name
 
     # def class_keyword: () -> String
@@ -3991,11 +4264,18 @@ module Prism
       visitor.visit_class_variable_and_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -4011,7 +4291,7 @@ module Prism
       ClassVariableAndWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -4117,11 +4397,18 @@ module Prism
       visitor.visit_class_variable_operator_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -4137,7 +4424,7 @@ module Prism
       ClassVariableOperatorWriteNode.new(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
@@ -4229,11 +4516,18 @@ module Prism
       visitor.visit_class_variable_or_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -4249,7 +4543,7 @@ module Prism
       ClassVariableOrWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -4339,11 +4633,17 @@ module Prism
       visitor.visit_class_variable_read_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -4359,7 +4659,7 @@ module Prism
       ClassVariableReadNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -4416,11 +4716,17 @@ module Prism
       visitor.visit_class_variable_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -4436,7 +4742,7 @@ module Prism
       ClassVariableTargetNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -4492,11 +4798,18 @@ module Prism
       visitor.visit_class_variable_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -4512,7 +4825,7 @@ module Prism
       ClassVariableWriteNode.new(source, node_id, location, flags, name, name_loc, value, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
@@ -4621,11 +4934,18 @@ module Prism
       visitor.visit_constant_and_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -4641,7 +4961,7 @@ module Prism
       ConstantAndWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -4735,11 +5055,18 @@ module Prism
       visitor.visit_constant_operator_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -4755,7 +5082,7 @@ module Prism
       ConstantOperatorWriteNode.new(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
@@ -4847,11 +5174,18 @@ module Prism
       visitor.visit_constant_or_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -4867,7 +5201,7 @@ module Prism
       ConstantOrWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -4959,11 +5293,19 @@ module Prism
       visitor.visit_constant_path_and_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [target, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield target
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [target, value]
@@ -4979,7 +5321,7 @@ module Prism
       ConstantPathAndWriteNode.new(source, node_id, location, flags, target, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
@@ -5058,11 +5400,18 @@ module Prism
       visitor.visit_constant_path_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [parent]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield parent if parent
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -5080,7 +5429,7 @@ module Prism
       ConstantPathNode.new(source, node_id, location, flags, parent, name, delimiter_loc, name_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
@@ -5194,11 +5543,19 @@ module Prism
       visitor.visit_constant_path_operator_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [target, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield target
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [target, value]
@@ -5214,7 +5571,7 @@ module Prism
       ConstantPathOperatorWriteNode.new(source, node_id, location, flags, target, binary_operator_loc, value, binary_operator)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
@@ -5291,11 +5648,19 @@ module Prism
       visitor.visit_constant_path_or_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [target, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield target
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [target, value]
@@ -5311,7 +5676,7 @@ module Prism
       ConstantPathOrWriteNode.new(source, node_id, location, flags, target, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
@@ -5390,11 +5755,18 @@ module Prism
       visitor.visit_constant_path_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [parent]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield parent if parent
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -5412,7 +5784,7 @@ module Prism
       ConstantPathTargetNode.new(source, node_id, location, flags, parent, name, delimiter_loc, name_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
@@ -5510,11 +5882,19 @@ module Prism
       visitor.visit_constant_path_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [target, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield target
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [target, value]
@@ -5530,7 +5910,7 @@ module Prism
       ConstantPathWriteNode.new(source, node_id, location, flags, target, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
@@ -5618,11 +5998,17 @@ module Prism
       visitor.visit_constant_read_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -5638,7 +6024,7 @@ module Prism
       ConstantReadNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -5695,11 +6081,17 @@ module Prism
       visitor.visit_constant_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -5715,7 +6107,7 @@ module Prism
       ConstantTargetNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -5771,11 +6163,18 @@ module Prism
       visitor.visit_constant_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -5791,7 +6190,7 @@ module Prism
       ConstantWriteNode.new(source, node_id, location, flags, name, name_loc, value, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
@@ -5909,11 +6308,20 @@ module Prism
       visitor.visit_def_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, parameters, body]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver if receiver
+      yield parameters if parameters
+      yield body if body
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -5933,7 +6341,7 @@ module Prism
       DefNode.new(source, node_id, location, flags, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: StatementsNode | BeginNode | nil, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? }
@@ -6164,11 +6572,18 @@ module Prism
       visitor.visit_defined_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -6184,7 +6599,7 @@ module Prism
       DefinedNode.new(source, node_id, location, flags, lparen_loc, value, rparen_loc, keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location }
@@ -6308,11 +6723,18 @@ module Prism
       visitor.visit_else_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -6330,7 +6752,7 @@ module Prism
       ElseNode.new(source, node_id, location, flags, else_keyword_loc, statements, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location? }
@@ -6429,11 +6851,18 @@ module Prism
       visitor.visit_embedded_statements_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -6451,7 +6880,7 @@ module Prism
       EmbeddedStatementsNode.new(source, node_id, location, flags, opening_loc, statements, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, statements: StatementsNode?, closing_loc: Location }
@@ -6543,11 +6972,18 @@ module Prism
       visitor.visit_embedded_variable_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [variable]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield variable
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [variable]
@@ -6563,7 +6999,7 @@ module Prism
       EmbeddedVariableNode.new(source, node_id, location, flags, operator_loc, variable)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode }
@@ -6641,11 +7077,18 @@ module Prism
       visitor.visit_ensure_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -6663,7 +7106,7 @@ module Prism
       EnsureNode.new(source, node_id, location, flags, ensure_keyword_loc, statements, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location }
@@ -6753,11 +7196,17 @@ module Prism
       visitor.visit_false_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -6773,7 +7222,7 @@ module Prism
       FalseNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -6813,6 +7262,9 @@ module Prism
   #
   #     foo in Foo(*bar, baz, *qux)
   #            ^^^^^^^^^^^^^^^^^^^^
+  #
+  #     foo => *bar, baz, *qux
+  #            ^^^^^^^^^^^^^^^
   class FindPatternNode < Node
     # Initialize a new FindPatternNode node.
     def initialize(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc)
@@ -6833,11 +7285,21 @@ module Prism
       visitor.visit_find_pattern_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [constant, left, *requireds, right]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield constant if constant
+      yield left
+      requireds.each { |node| yield node }
+      yield right
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -6853,32 +7315,59 @@ module Prism
       [*constant, left, *requireds, right, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?left: SplatNode, ?requireds: Array[Prism::node], ?right: SplatNode | MissingNode, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode
+    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?left: SplatNode, ?requireds: Array[Prism::node], ?right: SplatNode | MissingNode, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode
     def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, left: self.left, requireds: self.requireds, right: self.right, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
       FindPatternNode.new(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, left: SplatNode, requireds: Array[Prism::node], right: SplatNode | MissingNode, opening_loc: Location?, closing_loc: Location? }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, left: SplatNode, requireds: Array[Prism::node], right: SplatNode | MissingNode, opening_loc: Location?, closing_loc: Location? }
     def deconstruct_keys(keys)
       { node_id: node_id, location: location, constant: constant, left: left, requireds: requireds, right: right, opening_loc: opening_loc, closing_loc: closing_loc }
     end
 
-    # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
+    # Represents the optional constant preceding the pattern
+    #
+    #     foo in Foo(*bar, baz, *qux)
+    #            ^^^
     attr_reader :constant
 
-    # attr_reader left: SplatNode
+    # Represents the first wildcard node in the pattern.
+    #
+    #     foo in *bar, baz, *qux
+    #            ^^^^
+    #
+    #     foo in Foo(*bar, baz, *qux)
+    #                ^^^^
     attr_reader :left
 
-    # attr_reader requireds: Array[Prism::node]
+    # Represents the nodes in between the wildcards.
+    #
+    #     foo in *bar, baz, *qux
+    #                  ^^^
+    #
+    #     foo in Foo(*bar, baz, 1, *qux)
+    #                      ^^^^^^
     attr_reader :requireds
 
-    # attr_reader right: SplatNode | MissingNode
+    # Represents the second wildcard node in the pattern.
+    #
+    #     foo in *bar, baz, *qux
+    #                       ^^^^
+    #
+    #     foo in Foo(*bar, baz, *qux)
+    #                           ^^^^
     attr_reader :right
 
-    # attr_reader opening_loc: Location?
+    # The location of the opening brace.
+    #
+    #     foo in [*bar, baz, *qux]
+    #            ^
+    #
+    #     foo in Foo(*bar, baz, *qux)
+    #               ^
     def opening_loc
       location = @opening_loc
       case location
@@ -6897,7 +7386,13 @@ module Prism
       repository.enter(node_id, :opening_loc) unless @opening_loc.nil?
     end
 
-    # attr_reader closing_loc: Location?
+    # The location of the closing brace.
+    #
+    #     foo in [*bar, baz, *qux]
+    #                            ^
+    #
+    #     foo in Foo(*bar, baz, *qux)
+    #                               ^
     def closing_loc
       location = @closing_loc
       case location
@@ -6976,11 +7471,19 @@ module Prism
       visitor.visit_flip_flop_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [left, right]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield left if left
+      yield right if right
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -6999,7 +7502,7 @@ module Prism
       FlipFlopNode.new(source, node_id, location, flags, left, right, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
@@ -7081,11 +7584,17 @@ module Prism
       visitor.visit_float_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -7101,7 +7610,7 @@ module Prism
       FloatNode.new(source, node_id, location, flags, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Float }
@@ -7160,11 +7669,20 @@ module Prism
       visitor.visit_for_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [index, collection, statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield index
+      yield collection
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -7184,7 +7702,7 @@ module Prism
       ForNode.new(source, node_id, location, flags, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location }
@@ -7351,11 +7869,17 @@ module Prism
       visitor.visit_forwarding_arguments_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -7371,7 +7895,7 @@ module Prism
       ForwardingArgumentsNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -7420,11 +7944,17 @@ module Prism
       visitor.visit_forwarding_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -7440,7 +7970,7 @@ module Prism
       ForwardingParameterNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -7470,10 +8000,15 @@ module Prism
     end
   end
 
-  # Represents the use of the `super` keyword without parentheses or arguments.
+  # Represents the use of the `super` keyword without parentheses or arguments, but which might have a block.
   #
   #     super
   #     ^^^^^
+  #
+  #     super { 123 }
+  #     ^^^^^^^^^^^^^
+  #
+  # If it has any other arguments, it would be a `SuperNode` instead.
   class ForwardingSuperNode < Node
     # Initialize a new ForwardingSuperNode node.
     def initialize(source, node_id, location, flags, block)
@@ -7489,11 +8024,18 @@ module Prism
       visitor.visit_forwarding_super_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [block]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield block if block
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -7511,7 +8053,7 @@ module Prism
       ForwardingSuperNode.new(source, node_id, location, flags, block)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, block: BlockNode? }
@@ -7519,7 +8061,7 @@ module Prism
       { node_id: node_id, location: location, block: block }
     end
 
-    # attr_reader block: BlockNode?
+    # All other arguments are forwarded as normal, except the original block is replaced with the new block.
     attr_reader :block
 
     # def inspect -> String
@@ -7567,11 +8109,18 @@ module Prism
       visitor.visit_global_variable_and_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -7587,7 +8136,7 @@ module Prism
       GlobalVariableAndWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -7681,11 +8230,18 @@ module Prism
       visitor.visit_global_variable_operator_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -7701,7 +8257,7 @@ module Prism
       GlobalVariableOperatorWriteNode.new(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
@@ -7793,11 +8349,18 @@ module Prism
       visitor.visit_global_variable_or_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -7813,7 +8376,7 @@ module Prism
       GlobalVariableOrWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -7903,11 +8466,17 @@ module Prism
       visitor.visit_global_variable_read_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -7923,7 +8492,7 @@ module Prism
       GlobalVariableReadNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -7980,11 +8549,17 @@ module Prism
       visitor.visit_global_variable_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -8000,7 +8575,7 @@ module Prism
       GlobalVariableTargetNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -8056,11 +8631,18 @@ module Prism
       visitor.visit_global_variable_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -8076,7 +8658,7 @@ module Prism
       GlobalVariableWriteNode.new(source, node_id, location, flags, name, name_loc, value, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
@@ -8184,11 +8766,18 @@ module Prism
       visitor.visit_hash_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*elements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      elements.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*elements]
@@ -8204,7 +8793,7 @@ module Prism
       HashNode.new(source, node_id, location, flags, opening_loc, elements, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location }
@@ -8296,6 +8885,12 @@ module Prism
   #
   #     foo => { a: 1, b: 2, **c }
   #            ^^^^^^^^^^^^^^^^^^^
+  #
+  #     foo => Bar[a: 1, b: 2]
+  #            ^^^^^^^^^^^^^^^
+  #
+  #     foo in { a: 1, b: 2 }
+  #            ^^^^^^^^^^^^^^
   class HashPatternNode < Node
     # Initialize a new HashPatternNode node.
     def initialize(source, node_id, location, flags, constant, elements, rest, opening_loc, closing_loc)
@@ -8315,11 +8910,20 @@ module Prism
       visitor.visit_hash_pattern_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [constant, *elements, rest]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield constant if constant
+      elements.each { |node| yield node }
+      yield rest if rest
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -8334,29 +8938,53 @@ module Prism
       [*constant, *elements, *rest, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode
+    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode
     def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, elements: self.elements, rest: self.rest, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
       HashPatternNode.new(source, node_id, location, flags, constant, elements, rest, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? }
     def deconstruct_keys(keys)
       { node_id: node_id, location: location, constant: constant, elements: elements, rest: rest, opening_loc: opening_loc, closing_loc: closing_loc }
     end
 
-    # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
+    # Represents the optional constant preceding the Hash.
+    #
+    #     foo => Bar[a: 1, b: 2]
+    #          ^^^
+    #
+    #     foo => Bar::Baz[a: 1, b: 2]
+    #          ^^^^^^^^
     attr_reader :constant
 
-    # attr_reader elements: Array[AssocNode]
+    # Represents the explicit named hash keys and values.
+    #
+    #     foo => { a: 1, b:, ** }
+    #              ^^^^^^^^
     attr_reader :elements
 
-    # attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil
+    # Represents the rest of the Hash keys and values. This can be named, unnamed, or explicitly forbidden via `**nil`, this last one results in a `NoKeywordsParameterNode`.
+    #
+    #     foo => { a: 1, b:, **c }
+    #                        ^^^
+    #
+    #     foo => { a: 1, b:, ** }
+    #                        ^^
+    #
+    #     foo => { a: 1, b:, **nil }
+    #                        ^^^^^
     attr_reader :rest
 
-    # attr_reader opening_loc: Location?
+    # The location of the opening brace.
+    #
+    #     foo => { a: 1 }
+    #            ^
+    #
+    #     foo => Bar[a: 1]
+    #               ^
     def opening_loc
       location = @opening_loc
       case location
@@ -8375,7 +9003,13 @@ module Prism
       repository.enter(node_id, :opening_loc) unless @opening_loc.nil?
     end
 
-    # attr_reader closing_loc: Location?
+    # The location of the closing brace.
+    #
+    #     foo => { a: 1 }
+    #                   ^
+    #
+    #     foo => Bar[a: 1]
+    #                    ^
     def closing_loc
       location = @closing_loc
       case location
@@ -8462,11 +9096,20 @@ module Prism
       visitor.visit_if_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [predicate, statements, subsequent]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield predicate
+      yield statements if statements
+      yield subsequent if subsequent
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -8486,7 +9129,7 @@ module Prism
       IfNode.new(source, node_id, location, flags, if_keyword_loc, predicate, then_keyword_loc, statements, subsequent, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: ElseNode | IfNode | nil, end_keyword_loc: Location? }
@@ -8668,11 +9311,18 @@ module Prism
       visitor.visit_imaginary_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [numeric]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield numeric
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [numeric]
@@ -8688,7 +9338,7 @@ module Prism
       ImaginaryNode.new(source, node_id, location, flags, numeric)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numeric: FloatNode | IntegerNode | RationalNode }
@@ -8747,11 +9397,18 @@ module Prism
       visitor.visit_implicit_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -8767,7 +9424,7 @@ module Prism
       ImplicitNode.new(source, node_id, location, flags, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode }
@@ -8828,11 +9485,17 @@ module Prism
       visitor.visit_implicit_rest_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -8848,7 +9511,7 @@ module Prism
       ImplicitRestNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -8900,11 +9563,19 @@ module Prism
       visitor.visit_in_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [pattern, statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield pattern
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -8923,7 +9594,7 @@ module Prism
       InNode.new(source, node_id, location, flags, pattern, statements, in_loc, then_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location? }
@@ -9031,11 +9702,21 @@ module Prism
       visitor.visit_index_and_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, arguments, block, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver if receiver
+      yield arguments if arguments
+      yield block if block
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -9056,7 +9737,7 @@ module Prism
       IndexAndWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
@@ -9232,11 +9913,21 @@ module Prism
       visitor.visit_index_operator_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, arguments, block, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver if receiver
+      yield arguments if arguments
+      yield block if block
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -9257,7 +9948,7 @@ module Prism
       IndexOperatorWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
@@ -9431,11 +10122,21 @@ module Prism
       visitor.visit_index_or_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, arguments, block, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver if receiver
+      yield arguments if arguments
+      yield block if block
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -9456,7 +10157,7 @@ module Prism
       IndexOrWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
@@ -9636,11 +10337,20 @@ module Prism
       visitor.visit_index_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [receiver, arguments, block]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield receiver
+      yield arguments if arguments
+      yield block if block
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -9660,7 +10370,7 @@ module Prism
       IndexTargetNode.new(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode? }
@@ -9783,11 +10493,18 @@ module Prism
       visitor.visit_instance_variable_and_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -9803,7 +10520,7 @@ module Prism
       InstanceVariableAndWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -9897,11 +10614,18 @@ module Prism
       visitor.visit_instance_variable_operator_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -9917,7 +10641,7 @@ module Prism
       InstanceVariableOperatorWriteNode.new(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
@@ -10009,11 +10733,18 @@ module Prism
       visitor.visit_instance_variable_or_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -10029,7 +10760,7 @@ module Prism
       InstanceVariableOrWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -10119,11 +10850,17 @@ module Prism
       visitor.visit_instance_variable_read_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -10139,7 +10876,7 @@ module Prism
       InstanceVariableReadNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -10196,11 +10933,17 @@ module Prism
       visitor.visit_instance_variable_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -10216,7 +10959,7 @@ module Prism
       InstanceVariableTargetNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -10272,11 +11015,18 @@ module Prism
       visitor.visit_instance_variable_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -10292,7 +11042,7 @@ module Prism
       InstanceVariableWriteNode.new(source, node_id, location, flags, name, name_loc, value, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
@@ -10398,11 +11148,17 @@ module Prism
       visitor.visit_integer_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -10418,7 +11174,7 @@ module Prism
       IntegerNode.new(source, node_id, location, flags, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Integer }
@@ -10494,11 +11250,18 @@ module Prism
       visitor.visit_interpolated_match_last_line_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*parts]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      parts.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*parts]
@@ -10514,7 +11277,7 @@ module Prism
       InterpolatedMatchLastLineNode.new(source, node_id, location, flags, opening_loc, parts, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
@@ -10664,11 +11427,18 @@ module Prism
       visitor.visit_interpolated_regular_expression_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*parts]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      parts.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*parts]
@@ -10684,7 +11454,7 @@ module Prism
       InterpolatedRegularExpressionNode.new(source, node_id, location, flags, opening_loc, parts, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
@@ -10834,11 +11604,18 @@ module Prism
       visitor.visit_interpolated_string_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*parts]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      parts.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*parts]
@@ -10849,15 +11626,15 @@ module Prism
       [*opening_loc, *parts, *closing_loc] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode], ?closing_loc: Location?) -> InterpolatedStringNode
+    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], ?closing_loc: Location?) -> InterpolatedStringNode
     def copy(node_id: self.node_id, location: self.location, flags: self.flags, opening_loc: self.opening_loc, parts: self.parts, closing_loc: self.closing_loc)
       InterpolatedStringNode.new(source, node_id, location, flags, opening_loc, parts, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode], closing_loc: Location? }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], closing_loc: Location? }
     def deconstruct_keys(keys)
       { node_id: node_id, location: location, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc }
     end
@@ -10891,7 +11668,7 @@ module Prism
       repository.enter(node_id, :opening_loc) unless @opening_loc.nil?
     end
 
-    # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode]
+    # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode]
     attr_reader :parts
 
     # attr_reader closing_loc: Location?
@@ -10971,11 +11748,18 @@ module Prism
       visitor.visit_interpolated_symbol_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*parts]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      parts.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*parts]
@@ -10991,7 +11775,7 @@ module Prism
       InterpolatedSymbolNode.new(source, node_id, location, flags, opening_loc, parts, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location? }
@@ -11097,11 +11881,18 @@ module Prism
       visitor.visit_interpolated_x_string_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*parts]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      parts.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*parts]
@@ -11117,7 +11908,7 @@ module Prism
       InterpolatedXStringNode.new(source, node_id, location, flags, opening_loc, parts, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
@@ -11208,11 +11999,17 @@ module Prism
       visitor.visit_it_local_variable_read_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -11228,7 +12025,7 @@ module Prism
       ItLocalVariableReadNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -11276,11 +12073,17 @@ module Prism
       visitor.visit_it_parameters_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -11296,7 +12099,7 @@ module Prism
       ItParametersNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -11345,11 +12148,18 @@ module Prism
       visitor.visit_keyword_hash_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*elements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      elements.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*elements]
@@ -11365,7 +12175,7 @@ module Prism
       KeywordHashNode.new(source, node_id, location, flags, elements)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[AssocNode | AssocSplatNode] }
@@ -11428,11 +12238,17 @@ module Prism
       visitor.visit_keyword_rest_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -11448,7 +12264,7 @@ module Prism
       KeywordRestParameterNode.new(source, node_id, location, flags, name, name_loc, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
@@ -11551,11 +12367,19 @@ module Prism
       visitor.visit_lambda_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [parameters, body]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield parameters if parameters
+      yield body if body
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -11574,7 +12398,7 @@ module Prism
       LambdaNode.new(source, node_id, location, flags, locals, operator_loc, opening_loc, closing_loc, parameters, body)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil }
@@ -11697,11 +12521,18 @@ module Prism
       visitor.visit_local_variable_and_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -11717,7 +12548,7 @@ module Prism
       LocalVariableAndWriteNode.new(source, node_id, location, flags, name_loc, operator_loc, value, name, depth)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer }
@@ -11816,11 +12647,18 @@ module Prism
       visitor.visit_local_variable_operator_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -11836,7 +12674,7 @@ module Prism
       LocalVariableOperatorWriteNode.new(source, node_id, location, flags, name_loc, binary_operator_loc, value, name, binary_operator, depth)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer }
@@ -11933,11 +12771,18 @@ module Prism
       visitor.visit_local_variable_or_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -11953,7 +12798,7 @@ module Prism
       LocalVariableOrWriteNode.new(source, node_id, location, flags, name_loc, operator_loc, value, name, depth)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer }
@@ -12048,11 +12893,17 @@ module Prism
       visitor.visit_local_variable_read_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -12068,7 +12919,7 @@ module Prism
       LocalVariableReadNode.new(source, node_id, location, flags, name, depth)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer }
@@ -12124,6 +12975,9 @@ module Prism
   #
   #     foo, bar = baz
   #     ^^^  ^^^
+  #
+  #     foo => baz
+  #            ^^^
   class LocalVariableTargetNode < Node
     # Initialize a new LocalVariableTargetNode node.
     def initialize(source, node_id, location, flags, name, depth)
@@ -12140,11 +12994,17 @@ module Prism
       visitor.visit_local_variable_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -12160,7 +13020,7 @@ module Prism
       LocalVariableTargetNode.new(source, node_id, location, flags, name, depth)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer }
@@ -12221,11 +13081,18 @@ module Prism
       visitor.visit_local_variable_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -12241,7 +13108,7 @@ module Prism
       LocalVariableWriteNode.new(source, node_id, location, flags, name, depth, name_loc, value, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location }
@@ -12364,11 +13231,17 @@ module Prism
       visitor.visit_match_last_line_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -12384,7 +13257,7 @@ module Prism
       MatchLastLineNode.new(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
@@ -12552,11 +13425,19 @@ module Prism
       visitor.visit_match_predicate_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value, pattern]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+      yield pattern
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value, pattern]
@@ -12572,7 +13453,7 @@ module Prism
       MatchPredicateNode.new(source, node_id, location, flags, value, pattern, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location }
@@ -12650,11 +13531,19 @@ module Prism
       visitor.visit_match_required_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value, pattern]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+      yield pattern
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value, pattern]
@@ -12670,7 +13559,7 @@ module Prism
       MatchRequiredNode.new(source, node_id, location, flags, value, pattern, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location }
@@ -12678,13 +13567,61 @@ module Prism
       { node_id: node_id, location: location, value: value, pattern: pattern, operator_loc: operator_loc }
     end
 
-    # attr_reader value: Prism::node
+    # Represents the left-hand side of the operator.
+    #
+    #     foo => bar
+    #     ^^^
     attr_reader :value
 
-    # attr_reader pattern: Prism::node
+    # Represents the right-hand side of the operator. The type of the node depends on the expression.
+    #
+    # Anything that looks like a local variable name (including `_`) will result in a `LocalVariableTargetNode`.
+    #
+    #     foo => a # This is equivalent to writing `a = foo`
+    #            ^
+    #
+    # Using an explicit `Array` or combining expressions with `,` will result in a `ArrayPatternNode`. This can be preceded by a constant.
+    #
+    #     foo => [a]
+    #            ^^^
+    #
+    #     foo => a, b
+    #            ^^^^
+    #
+    #     foo => Bar[a, b]
+    #            ^^^^^^^^^
+    #
+    # If the array pattern contains at least two wildcard matches, a `FindPatternNode` is created instead.
+    #
+    #     foo => *, 1, *a
+    #            ^^^^^
+    #
+    # Using an explicit `Hash` or a constant with square brackets and hash keys in the square brackets will result in a `HashPatternNode`.
+    #
+    #     foo => { a: 1, b: }
+    #
+    #     foo => Bar[a: 1, b:]
+    #
+    #     foo => Bar[**]
+    #
+    # To use any variable that needs run time evaluation, pinning is required. This results in a `PinnedVariableNode`
+    #
+    #     foo => ^a
+    #            ^^
+    #
+    # Similar, any expression can be used with pinning. This results in a `PinnedExpressionNode`.
+    #
+    #     foo => ^(a + 1)
+    #
+    # Anything else will result in the regular node for that expression, for example a `ConstantReadNode`.
+    #
+    #     foo => CONST
     attr_reader :pattern
 
-    # attr_reader operator_loc: Location
+    # The location of the operator.
+    #
+    #     foo => bar
+    #         ^^
     def operator_loc
       location = @operator_loc
       return location if location.is_a?(Location)
@@ -12747,11 +13684,19 @@ module Prism
       visitor.visit_match_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [call, *targets]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield call
+      targets.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [call, *targets]
@@ -12767,7 +13712,7 @@ module Prism
       MatchWriteNode.new(source, node_id, location, flags, call, targets)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, call: CallNode, targets: Array[LocalVariableTargetNode] }
@@ -12821,11 +13766,17 @@ module Prism
       visitor.visit_missing_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -12841,7 +13792,7 @@ module Prism
       MissingNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -12895,11 +13846,19 @@ module Prism
       visitor.visit_module_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [constant_path, body]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield constant_path
+      yield body if body
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -12918,7 +13877,7 @@ module Prism
       ModuleNode.new(source, node_id, location, flags, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], module_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | MissingNode, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
@@ -13031,11 +13990,20 @@ module Prism
       visitor.visit_multi_target_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*lefts, rest, *rights]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      lefts.each { |node| yield node }
+      yield rest if rest
+      rights.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -13055,7 +14023,7 @@ module Prism
       MultiTargetNode.new(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location? }
@@ -13204,11 +14172,21 @@ module Prism
       visitor.visit_multi_write_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*lefts, rest, *rights, value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      lefts.each { |node| yield node }
+      yield rest if rest
+      rights.each { |node| yield node }
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -13229,7 +14207,7 @@ module Prism
       MultiWriteNode.new(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node }
@@ -13402,11 +14380,18 @@ module Prism
       visitor.visit_next_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [arguments]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield arguments if arguments
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -13424,7 +14409,7 @@ module Prism
       NextNode.new(source, node_id, location, flags, arguments, keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
@@ -13495,11 +14480,17 @@ module Prism
       visitor.visit_nil_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -13515,7 +14506,7 @@ module Prism
       NilNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -13566,11 +14557,17 @@ module Prism
       visitor.visit_no_keywords_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -13586,7 +14583,7 @@ module Prism
       NoKeywordsParameterNode.new(source, node_id, location, flags, operator_loc, keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, keyword_loc: Location }
@@ -13673,11 +14670,17 @@ module Prism
       visitor.visit_numbered_parameters_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -13693,7 +14696,7 @@ module Prism
       NumberedParametersNode.new(source, node_id, location, flags, maximum)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, maximum: Integer }
@@ -13746,11 +14749,17 @@ module Prism
       visitor.visit_numbered_reference_read_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -13766,7 +14775,7 @@ module Prism
       NumberedReferenceReadNode.new(source, node_id, location, flags, number)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, number: Integer }
@@ -13828,11 +14837,18 @@ module Prism
       visitor.visit_optional_keyword_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -13848,7 +14864,7 @@ module Prism
       OptionalKeywordParameterNode.new(source, node_id, location, flags, name, name_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node }
@@ -13929,11 +14945,18 @@ module Prism
       visitor.visit_optional_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [value]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield value
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [value]
@@ -13949,7 +14972,7 @@ module Prism
       OptionalParameterNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
@@ -14047,11 +15070,19 @@ module Prism
       visitor.visit_or_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [left, right]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield left
+      yield right
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [left, right]
@@ -14067,7 +15098,7 @@ module Prism
       OrNode.new(source, node_id, location, flags, left, right, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
@@ -14165,11 +15196,24 @@ module Prism
       visitor.visit_parameters_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*requireds, *optionals, rest, *posts, *keywords, keyword_rest, block]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      requireds.each { |node| yield node }
+      optionals.each { |node| yield node }
+      yield rest if rest
+      posts.each { |node| yield node }
+      keywords.each { |node| yield node }
+      yield keyword_rest if keyword_rest
+      yield block if block
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -14193,7 +15237,7 @@ module Prism
       ParametersNode.new(source, node_id, location, flags, requireds, optionals, rest, posts, keywords, keyword_rest, block)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode? }
@@ -14276,11 +15320,18 @@ module Prism
       visitor.visit_parentheses_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [body]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield body if body
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -14298,7 +15349,7 @@ module Prism
       ParenthesesNode.new(source, node_id, location, flags, body, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Prism::node?, opening_loc: Location, closing_loc: Location }
@@ -14398,11 +15449,18 @@ module Prism
       visitor.visit_pinned_expression_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [expression]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield expression
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [expression]
@@ -14418,7 +15476,7 @@ module Prism
       PinnedExpressionNode.new(source, node_id, location, flags, expression, operator_loc, lparen_loc, rparen_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location }
@@ -14426,10 +15484,16 @@ module Prism
       { node_id: node_id, location: location, expression: expression, operator_loc: operator_loc, lparen_loc: lparen_loc, rparen_loc: rparen_loc }
     end
 
-    # attr_reader expression: Prism::node
+    # The expression used in the pinned expression
+    #
+    #     foo in ^(bar)
+    #              ^^^
     attr_reader :expression
 
-    # attr_reader operator_loc: Location
+    # The location of the `^` operator
+    #
+    #     foo in ^(bar)
+    #            ^
     def operator_loc
       location = @operator_loc
       return location if location.is_a?(Location)
@@ -14442,7 +15506,10 @@ module Prism
       repository.enter(node_id, :operator_loc)
     end
 
-    # attr_reader lparen_loc: Location
+    # The location of the opening parenthesis.
+    #
+    #     foo in ^(bar)
+    #             ^
     def lparen_loc
       location = @lparen_loc
       return location if location.is_a?(Location)
@@ -14455,7 +15522,10 @@ module Prism
       repository.enter(node_id, :lparen_loc)
     end
 
-    # attr_reader rparen_loc: Location
+    # The location of the closing parenthesis.
+    #
+    #     foo in ^(bar)
+    #                 ^
     def rparen_loc
       location = @rparen_loc
       return location if location.is_a?(Location)
@@ -14529,11 +15599,18 @@ module Prism
       visitor.visit_pinned_variable_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [variable]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield variable
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [variable]
@@ -14549,7 +15626,7 @@ module Prism
       PinnedVariableNode.new(source, node_id, location, flags, variable, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, operator_loc: Location }
@@ -14557,10 +15634,16 @@ module Prism
       { node_id: node_id, location: location, variable: variable, operator_loc: operator_loc }
     end
 
-    # attr_reader variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode
+    # The variable used in the pinned expression
+    #
+    #     foo in ^bar
+    #             ^^^
     attr_reader :variable
 
-    # attr_reader operator_loc: Location
+    # The location of the `^` operator
+    #
+    #     foo in ^bar
+    #            ^
     def operator_loc
       location = @operator_loc
       return location if location.is_a?(Location)
@@ -14624,11 +15707,18 @@ module Prism
       visitor.visit_post_execution_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -14646,7 +15736,7 @@ module Prism
       PostExecutionNode.new(source, node_id, location, flags, statements, keyword_loc, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location }
@@ -14759,11 +15849,18 @@ module Prism
       visitor.visit_pre_execution_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -14781,7 +15878,7 @@ module Prism
       PreExecutionNode.new(source, node_id, location, flags, statements, keyword_loc, opening_loc, closing_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location }
@@ -14889,11 +15986,18 @@ module Prism
       visitor.visit_program_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [statements]
@@ -14909,7 +16013,7 @@ module Prism
       ProgramNode.new(source, node_id, location, flags, locals, statements)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], statements: StatementsNode }
@@ -14972,11 +16076,19 @@ module Prism
       visitor.visit_range_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [left, right]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield left if left
+      yield right if right
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -14995,7 +16107,7 @@ module Prism
       RangeNode.new(source, node_id, location, flags, left, right, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
@@ -15091,11 +16203,17 @@ module Prism
       visitor.visit_rational_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -15111,7 +16229,7 @@ module Prism
       RationalNode.new(source, node_id, location, flags, numerator, denominator)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numerator: Integer, denominator: Integer }
@@ -15192,11 +16310,17 @@ module Prism
       visitor.visit_redo_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -15212,7 +16336,7 @@ module Prism
       RedoNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -15264,11 +16388,17 @@ module Prism
       visitor.visit_regular_expression_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -15284,7 +16414,7 @@ module Prism
       RegularExpressionNode.new(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
@@ -15452,11 +16582,17 @@ module Prism
       visitor.visit_required_keyword_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -15472,7 +16608,7 @@ module Prism
       RequiredKeywordParameterNode.new(source, node_id, location, flags, name, name_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location }
@@ -15546,11 +16682,17 @@ module Prism
       visitor.visit_required_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -15566,7 +16708,7 @@ module Prism
       RequiredParameterNode.new(source, node_id, location, flags, name)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
@@ -15627,11 +16769,19 @@ module Prism
       visitor.visit_rescue_modifier_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [expression, rescue_expression]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield expression
+      yield rescue_expression
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [expression, rescue_expression]
@@ -15647,7 +16797,7 @@ module Prism
       RescueModifierNode.new(source, node_id, location, flags, expression, keyword_loc, rescue_expression)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node }
@@ -15734,11 +16884,21 @@ module Prism
       visitor.visit_rescue_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*exceptions, reference, statements, subsequent]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      exceptions.each { |node| yield node }
+      yield reference if reference
+      yield statements if statements
+      yield subsequent if subsequent
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -15759,7 +16919,7 @@ module Prism
       RescueNode.new(source, node_id, location, flags, keyword_loc, exceptions, operator_loc, reference, then_keyword_loc, statements, subsequent)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: RescueNode? }
@@ -15897,11 +17057,17 @@ module Prism
       visitor.visit_rest_parameter_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -15917,7 +17083,7 @@ module Prism
       RestParameterNode.new(source, node_id, location, flags, name, name_loc, operator_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
@@ -16014,11 +17180,17 @@ module Prism
       visitor.visit_retry_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -16034,7 +17206,7 @@ module Prism
       RetryNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -16084,11 +17256,18 @@ module Prism
       visitor.visit_return_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [arguments]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield arguments if arguments
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -16106,7 +17285,7 @@ module Prism
       ReturnNode.new(source, node_id, location, flags, keyword_loc, arguments)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, arguments: ArgumentsNode? }
@@ -16177,11 +17356,17 @@ module Prism
       visitor.visit_self_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -16197,7 +17382,7 @@ module Prism
       SelfNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -16247,11 +17432,18 @@ module Prism
       visitor.visit_shareable_constant_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [write]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield write
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [write]
@@ -16267,7 +17459,7 @@ module Prism
       ShareableConstantNode.new(source, node_id, location, flags, write)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode }
@@ -16341,11 +17533,19 @@ module Prism
       visitor.visit_singleton_class_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [expression, body]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield expression
+      yield body if body
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -16364,7 +17564,7 @@ module Prism
       SingletonClassNode.new(source, node_id, location, flags, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location }
@@ -16482,11 +17682,17 @@ module Prism
       visitor.visit_source_encoding_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -16502,7 +17708,7 @@ module Prism
       SourceEncodingNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -16551,11 +17757,17 @@ module Prism
       visitor.visit_source_file_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -16571,7 +17783,7 @@ module Prism
       SourceFileNode.new(source, node_id, location, flags, filepath)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, filepath: String }
@@ -16644,11 +17856,17 @@ module Prism
       visitor.visit_source_line_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -16664,7 +17882,7 @@ module Prism
       SourceLineNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -16714,11 +17932,18 @@ module Prism
       visitor.visit_splat_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [expression]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield expression if expression
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -16736,7 +17961,7 @@ module Prism
       SplatNode.new(source, node_id, location, flags, operator_loc, expression)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, expression: Prism::node? }
@@ -16808,11 +18033,18 @@ module Prism
       visitor.visit_statements_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*body]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      body.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*body]
@@ -16828,7 +18060,7 @@ module Prism
       StatementsNode.new(source, node_id, location, flags, body)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Array[Prism::node] }
@@ -16891,11 +18123,17 @@ module Prism
       visitor.visit_string_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -16911,7 +18149,7 @@ module Prism
       StringNode.new(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String }
@@ -17042,6 +18280,8 @@ module Prism
   #
   #     super foo, bar
   #     ^^^^^^^^^^^^^^
+  #
+  # If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead.
   class SuperNode < Node
     # Initialize a new SuperNode node.
     def initialize(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc, block)
@@ -17061,11 +18301,19 @@ module Prism
       visitor.visit_super_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [arguments, block]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield arguments if arguments
+      yield block if block
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -17084,7 +18332,7 @@ module Prism
       SuperNode.new(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc, block)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
@@ -17124,7 +18372,7 @@ module Prism
       repository.enter(node_id, :lparen_loc) unless @lparen_loc.nil?
     end
 
-    # attr_reader arguments: ArgumentsNode?
+    # Can be only `nil` when there are empty parentheses, like `super()`.
     attr_reader :arguments
 
     # attr_reader rparen_loc: Location?
@@ -17216,11 +18464,17 @@ module Prism
       visitor.visit_symbol_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -17236,7 +18490,7 @@ module Prism
       SymbolNode.new(source, node_id, location, flags, opening_loc, value_loc, closing_loc, unescaped)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String }
@@ -17379,11 +18633,17 @@ module Prism
       visitor.visit_true_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -17399,7 +18659,7 @@ module Prism
       TrueNode.new(source, node_id, location, flags)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
@@ -17449,11 +18709,18 @@ module Prism
       visitor.visit_undef_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*names]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      names.each { |node| yield node }
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       [*names]
@@ -17469,7 +18736,7 @@ module Prism
       UndefNode.new(source, node_id, location, flags, names, keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location }
@@ -17550,11 +18817,20 @@ module Prism
       visitor.visit_unless_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [predicate, statements, else_clause]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield predicate
+      yield statements if statements
+      yield else_clause if else_clause
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -17574,7 +18850,7 @@ module Prism
       UnlessNode.new(source, node_id, location, flags, keyword_loc, predicate, then_keyword_loc, statements, else_clause, end_keyword_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, else_clause: ElseNode?, end_keyword_loc: Location? }
@@ -17736,11 +19012,19 @@ module Prism
       visitor.visit_until_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [predicate, statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield predicate
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -17759,7 +19043,7 @@ module Prism
       UntilNode.new(source, node_id, location, flags, keyword_loc, do_keyword_loc, closing_loc, predicate, statements)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
@@ -17896,11 +19180,19 @@ module Prism
       visitor.visit_when_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [*conditions, statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      conditions.each { |node| yield node }
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -17919,7 +19211,7 @@ module Prism
       WhenNode.new(source, node_id, location, flags, keyword_loc, conditions, then_keyword_loc, statements)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode? }
@@ -18028,11 +19320,19 @@ module Prism
       visitor.visit_while_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [predicate, statements]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield predicate
+      yield statements if statements
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -18051,7 +19351,7 @@ module Prism
       WhileNode.new(source, node_id, location, flags, keyword_loc, do_keyword_loc, closing_loc, predicate, statements)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
@@ -18186,11 +19486,17 @@ module Prism
       visitor.visit_x_string_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       []
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       []
@@ -18206,7 +19512,7 @@ module Prism
       XStringNode.new(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
@@ -18330,11 +19636,18 @@ module Prism
       visitor.visit_yield_node(self)
     end
 
-    # def child_nodes: () -> Array[nil | Node]
+    # def child_nodes: () -> Array[Node?]
     def child_nodes
       [arguments]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      yield arguments if arguments
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
@@ -18352,7 +19665,7 @@ module Prism
       YieldNode.new(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc)
     end
 
-    # def deconstruct: () -> Array[nil | Node]
+    # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location? }