prism 1.5.1 → 1.9.0

data/lib/prism/node.rb

@@ -194,25 +194,13 @@ module Prism
     def tunnel(line, column)
       queue = [self] #: Array[Prism::node]
       result = [] #: Array[Prism::node]
+      offset = source.byte_offset(line, column)
 
       while (node = queue.shift)
         result << node
 
-        node.compact_child_nodes.each do |child_node|
-          child_location = child_node.location
-
-          start_line = child_location.start_line
-          end_line = child_location.end_line
-
-          if start_line == end_line
-            if line == start_line && column >= child_location.start_column && column < child_location.end_column
-              queue << child_node
-              break
-            end
-          elsif (line == start_line && column >= child_location.start_column) || (line == end_line && column < child_location.end_column)
-            queue << child_node
-            break
-          elsif line > start_line && line < end_line
+        node.each_child_node do |child_node|
+          if child_node.start_offset <= offset && offset < child_node.end_offset
             queue << child_node
             break
           end
@@ -223,7 +211,7 @@ module Prism
     end
 
     # Returns the first node that matches the given block when visited in a
-    # depth-first search. This is useful for finding a node that matches a
+    # breadth-first search. This is useful for finding a node that matches a
     # particular condition.
     #
     #     node.breadth_first_search { |node| node.node_id == node_id }
@@ -238,6 +226,26 @@ module Prism
 
       nil
     end
+    alias find breadth_first_search
+
+    # Returns all of the nodes that match the given block when visited in a
+    # breadth-first search. This is useful for finding all nodes that match a
+    # particular condition.
+    #
+    #     node.breadth_first_search_all { |node| node.is_a?(Prism::CallNode) }
+    #
+    def breadth_first_search_all(&block)
+      queue = [self] #: Array[Prism::node]
+      results = [] #: Array[Prism::node]
+
+      while (node = queue.shift)
+        results << node if yield node
+        queue.concat(node.compact_child_nodes)
+      end
+
+      results
+    end
+    alias find_all breadth_first_search_all
 
     # Returns a list of the fields that exist for this node class. Fields
     # describe the structure of the node. This kind of reflection is useful for
@@ -270,6 +278,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
@@ -338,6 +353,14 @@ module Prism
       [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]
@@ -445,6 +468,14 @@ module Prism
       [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]
@@ -564,6 +595,14 @@ module Prism
       [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]
@@ -671,6 +710,14 @@ module Prism
       [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]
@@ -782,6 +829,13 @@ module Prism
       [*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]
@@ -887,6 +941,13 @@ module Prism
       [*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]
@@ -1044,6 +1105,16 @@ module Prism
       [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]
@@ -1212,6 +1283,14 @@ module Prism
       [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]
@@ -1333,6 +1412,13 @@ module Prism
       [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]
@@ -1433,6 +1519,12 @@ module Prism
       []
     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
       []
@@ -1517,6 +1609,16 @@ module Prism
       [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]
@@ -1676,6 +1778,13 @@ module Prism
       [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]
@@ -1776,6 +1885,12 @@ module Prism
       []
     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
       []
@@ -1862,6 +1977,14 @@ module Prism
       [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]
@@ -1910,10 +2033,10 @@ module Prism
     #                          ^^^^^^
     attr_reader :body
 
-    # Represents the location of the opening `|`.
+    # Represents the location of the opening `{` or `do`.
     #
     #     [1, 2, 3].each { |i| puts x }
-    #                      ^
+    #                    ^
     def opening_loc
       location = @opening_loc
       return location if location.is_a?(Location)
@@ -1926,10 +2049,10 @@ module Prism
       repository.enter(node_id, :opening_loc)
     end
 
-    # Represents the location of the closing `|`.
+    # Represents the location of the closing `}` or `end`.
     #
     #     [1, 2, 3].each { |i| puts x }
-    #                        ^
+    #                                 ^
     def closing_loc
       location = @closing_loc
       return location if location.is_a?(Location)
@@ -2007,6 +2130,12 @@ module Prism
       []
     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
       []
@@ -2143,6 +2272,14 @@ module Prism
       [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]
@@ -2303,6 +2440,13 @@ module Prism
       [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]
@@ -2409,6 +2553,14 @@ module Prism
       [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]
@@ -2605,7 +2757,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
@@ -2617,6 +2769,7 @@ module Prism
       @opening_loc = opening_loc
       @arguments = arguments
       @closing_loc = closing_loc
+      @equal_loc = equal_loc
       @block = block
     end
 
@@ -2630,6 +2783,15 @@ module Prism
       [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]
@@ -2641,20 +2803,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[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
@@ -2791,6 +2953,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 }
@@ -2817,6 +3004,11 @@ module Prism
       closing_loc&.slice
     end
 
+    # def equal: () -> String?
+    def equal
+      equal_loc&.slice
+    end
+
     # def inspect -> String
     def inspect
       InspectVisitor.compose(self)
@@ -2844,6 +3036,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
@@ -2879,6 +3072,14 @@ module Prism
       [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]
@@ -3086,6 +3287,14 @@ module Prism
       [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]
@@ -3296,6 +3505,13 @@ module Prism
       [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]
@@ -3446,6 +3662,14 @@ module Prism
       [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]
@@ -3557,6 +3781,15 @@ module Prism
       [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]
@@ -3702,6 +3935,15 @@ module Prism
       [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]
@@ -3732,7 +3974,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.
@@ -3848,6 +4090,15 @@ module Prism
       [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]
@@ -4026,6 +4277,13 @@ module Prism
       [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]
@@ -4152,6 +4410,13 @@ module Prism
       [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]
@@ -4264,6 +4529,13 @@ module Prism
       [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]
@@ -4374,6 +4646,12 @@ module Prism
       []
     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
       []
@@ -4451,6 +4729,12 @@ module Prism
       []
     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
       []
@@ -4527,6 +4811,13 @@ module Prism
       [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]
@@ -4656,6 +4947,13 @@ module Prism
       [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]
@@ -4770,6 +5068,13 @@ module Prism
       [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]
@@ -4882,6 +5187,13 @@ module Prism
       [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]
@@ -4994,6 +5306,14 @@ module Prism
       [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]
@@ -5093,6 +5413,13 @@ module Prism
       [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]
@@ -5229,6 +5556,14 @@ module Prism
       [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]
@@ -5326,6 +5661,14 @@ module Prism
       [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]
@@ -5425,6 +5768,13 @@ module Prism
       [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]
@@ -5545,6 +5895,14 @@ module Prism
       [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]
@@ -5653,6 +6011,12 @@ module Prism
       []
     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
       []
@@ -5730,6 +6094,12 @@ module Prism
       []
     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
       []
@@ -5806,6 +6176,13 @@ module Prism
       [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]
@@ -5944,6 +6321,15 @@ module Prism
       [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]
@@ -6199,6 +6585,13 @@ module Prism
       [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]
@@ -6343,6 +6736,13 @@ module Prism
       [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]
@@ -6464,6 +6864,13 @@ module Prism
       [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]
@@ -6578,6 +6985,13 @@ module Prism
       [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]
@@ -6676,6 +7090,13 @@ module Prism
       [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]
@@ -6788,6 +7209,12 @@ module Prism
       []
     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
       []
@@ -6871,6 +7298,16 @@ module Prism
       [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]
@@ -7047,6 +7484,14 @@ module Prism
       [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]
@@ -7152,6 +7597,12 @@ module Prism
       []
     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
       []
@@ -7231,6 +7682,15 @@ module Prism
       [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]
@@ -7422,6 +7882,12 @@ module Prism
       []
     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
       []
@@ -7491,6 +7957,12 @@ module Prism
       []
     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
       []
@@ -7536,10 +8008,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)
@@ -7560,6 +8037,13 @@ module Prism
       [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]
@@ -7585,7 +8069,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
@@ -7638,6 +8122,13 @@ module Prism
       [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]
@@ -7752,6 +8243,13 @@ module Prism
       [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]
@@ -7864,6 +8362,13 @@ module Prism
       [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]
@@ -7974,6 +8479,12 @@ module Prism
       []
     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
       []
@@ -8051,6 +8562,12 @@ module Prism
       []
     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
       []
@@ -8127,6 +8644,13 @@ module Prism
       [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]
@@ -8255,6 +8779,13 @@ module Prism
       [*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]
@@ -8392,6 +8923,15 @@ module Prism
       [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]
@@ -8569,6 +9109,15 @@ module Prism
       [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]
@@ -8775,6 +9324,13 @@ module Prism
       [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]
@@ -8854,6 +9410,13 @@ module Prism
       [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]
@@ -8935,6 +9498,12 @@ module Prism
       []
     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
       []
@@ -9007,6 +9576,14 @@ module Prism
       [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]
@@ -9138,6 +9715,16 @@ module Prism
       [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]
@@ -9339,6 +9926,16 @@ module Prism
       [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]
@@ -9538,6 +10135,16 @@ module Prism
       [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]
@@ -9743,6 +10350,15 @@ module Prism
       [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]
@@ -9890,6 +10506,13 @@ module Prism
       [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]
@@ -10004,6 +10627,13 @@ module Prism
       [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]
@@ -10116,6 +10746,13 @@ module Prism
       [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]
@@ -10226,6 +10863,12 @@ module Prism
       []
     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
       []
@@ -10303,6 +10946,12 @@ module Prism
       []
     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
       []
@@ -10379,6 +11028,13 @@ module Prism
       [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]
@@ -10505,6 +11161,12 @@ module Prism
       []
     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
       []
@@ -10601,6 +11263,13 @@ module Prism
       [*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]
@@ -10771,6 +11440,13 @@ module Prism
       [*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]
@@ -10941,6 +11617,13 @@ module Prism
       [*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]
@@ -10951,7 +11634,7 @@ 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
@@ -10959,7 +11642,7 @@ module Prism
     # 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
@@ -10993,7 +11676,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?
@@ -11078,6 +11761,13 @@ module Prism
       [*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]
@@ -11204,6 +11894,13 @@ module Prism
       [*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]
@@ -11315,6 +12012,12 @@ module Prism
       []
     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
       []
@@ -11383,6 +12086,12 @@ module Prism
       []
     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
       []
@@ -11452,6 +12161,13 @@ module Prism
       [*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]
@@ -11535,6 +12251,12 @@ module Prism
       []
     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
       []
@@ -11658,6 +12380,14 @@ module Prism
       [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]
@@ -11804,6 +12534,13 @@ module Prism
       [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]
@@ -11923,6 +12660,13 @@ module Prism
       [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]
@@ -12040,6 +12784,13 @@ module Prism
       [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]
@@ -12155,6 +12906,12 @@ module Prism
       []
     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
       []
@@ -12250,6 +13007,12 @@ module Prism
       []
     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
       []
@@ -12331,6 +13094,13 @@ module Prism
       [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]
@@ -12474,6 +13244,12 @@ module Prism
       []
     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
       []
@@ -12662,6 +13438,14 @@ module Prism
       [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]
@@ -12760,6 +13544,14 @@ module Prism
       [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]
@@ -12905,6 +13697,14 @@ module Prism
       [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]
@@ -12979,6 +13779,12 @@ module Prism
       []
     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
       []
@@ -13053,6 +13859,14 @@ module Prism
       [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]
@@ -13189,6 +14003,15 @@ module Prism
       [*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]
@@ -13362,6 +14185,16 @@ module Prism
       [*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]
@@ -13560,6 +14393,13 @@ module Prism
       [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]
@@ -13653,6 +14493,12 @@ module Prism
       []
     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
       []
@@ -13724,6 +14570,12 @@ module Prism
       []
     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
       []
@@ -13831,6 +14683,12 @@ module Prism
       []
     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
       []
@@ -13904,6 +14762,12 @@ module Prism
       []
     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
       []
@@ -13986,6 +14850,13 @@ module Prism
       [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]
@@ -14087,6 +14958,13 @@ module Prism
       [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]
@@ -14205,6 +15083,14 @@ module Prism
       [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]
@@ -14323,6 +15209,19 @@ module Prism
       [*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]
@@ -14434,6 +15333,13 @@ module Prism
       [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]
@@ -14556,6 +15462,13 @@ module Prism
       [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]
@@ -14699,6 +15612,13 @@ module Prism
       [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]
@@ -14800,6 +15720,13 @@ module Prism
       [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]
@@ -14935,6 +15862,13 @@ module Prism
       [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]
@@ -15065,6 +15999,13 @@ module Prism
       [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]
@@ -15148,6 +16089,14 @@ module Prism
       [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]
@@ -15267,6 +16216,12 @@ module Prism
       []
     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
       []
@@ -15368,6 +16323,12 @@ module Prism
       []
     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
       []
@@ -15440,6 +16401,12 @@ module Prism
       []
     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
       []
@@ -15628,6 +16595,12 @@ module Prism
       []
     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
       []
@@ -15722,6 +16695,12 @@ module Prism
       []
     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
       []
@@ -15803,6 +16782,14 @@ module Prism
       [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]
@@ -15910,6 +16897,16 @@ module Prism
       [*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]
@@ -16073,6 +17070,12 @@ module Prism
       []
     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
       []
@@ -16190,6 +17193,12 @@ module Prism
       []
     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
       []
@@ -16260,6 +17269,13 @@ module Prism
       [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]
@@ -16353,6 +17369,12 @@ module Prism
       []
     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
       []
@@ -16423,6 +17445,13 @@ module Prism
       [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]
@@ -16517,6 +17546,14 @@ module Prism
       [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]
@@ -16658,6 +17695,12 @@ module Prism
       []
     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
       []
@@ -16727,6 +17770,12 @@ module Prism
       []
     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
       []
@@ -16820,6 +17869,12 @@ module Prism
       []
     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
       []
@@ -16890,6 +17945,13 @@ module Prism
       [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]
@@ -16984,6 +18046,13 @@ module Prism
       [*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]
@@ -17067,6 +18136,12 @@ module Prism
       []
     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
       []
@@ -17213,6 +18288,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)
@@ -17237,6 +18314,14 @@ module Prism
       [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]
@@ -17295,7 +18380,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?
@@ -17392,6 +18477,12 @@ module Prism
       []
     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
       []
@@ -17555,6 +18646,12 @@ module Prism
       []
     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
       []
@@ -17625,6 +18722,13 @@ module Prism
       [*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]
@@ -17726,6 +18830,15 @@ module Prism
       [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]
@@ -17912,6 +19025,14 @@ module Prism
       [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]
@@ -18072,6 +19193,14 @@ module Prism
       [*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]
@@ -18204,6 +19333,14 @@ module Prism
       [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]
@@ -18362,6 +19499,12 @@ module Prism
       []
     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
       []
@@ -18506,6 +19649,13 @@ module Prism
       [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]