prism 1.7.0 → 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]
@@ -2631,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]
@@ -2911,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]
@@ -3118,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]
@@ -3328,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]
@@ -3478,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]
@@ -3589,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]
@@ -3734,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]
@@ -3880,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]
@@ -4058,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]
@@ -4184,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]
@@ -4296,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]
@@ -4406,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
       []
@@ -4483,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
       []
@@ -4559,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]
@@ -4688,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]
@@ -4802,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]
@@ -4914,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]
@@ -5026,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]
@@ -5125,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]
@@ -5261,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]
@@ -5358,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]
@@ -5457,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]
@@ -5577,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]
@@ -5685,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
       []
@@ -5762,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
       []
@@ -5838,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]
@@ -5976,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]
@@ -6231,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]
@@ -6375,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]
@@ -6496,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]
@@ -6610,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]
@@ -6708,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]
@@ -6820,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
       []
@@ -6903,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]
@@ -7079,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]
@@ -7184,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
       []
@@ -7263,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]
@@ -7454,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
       []
@@ -7523,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
       []
@@ -7597,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]
@@ -7675,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]
@@ -7789,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]
@@ -7901,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]
@@ -8011,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
       []
@@ -8088,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
       []
@@ -8164,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]
@@ -8292,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]
@@ -8429,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]
@@ -8606,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]
@@ -8812,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]
@@ -8891,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]
@@ -8972,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
       []
@@ -9044,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]
@@ -9175,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]
@@ -9376,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]
@@ -9575,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]
@@ -9780,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]
@@ -9927,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]
@@ -10041,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]
@@ -10153,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]
@@ -10263,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
       []
@@ -10340,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
       []
@@ -10416,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]
@@ -10542,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
       []
@@ -10638,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]
@@ -10808,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]
@@ -10978,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]
@@ -11115,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]
@@ -11241,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]
@@ -11352,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
       []
@@ -11420,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
       []
@@ -11489,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]
@@ -11572,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
       []
@@ -11695,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]
@@ -11841,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]
@@ -11960,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]
@@ -12077,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]
@@ -12192,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
       []
@@ -12287,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
       []
@@ -12368,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]
@@ -12511,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
       []
@@ -12699,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]
@@ -12797,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]
@@ -12942,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]
@@ -13016,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
       []
@@ -13090,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]
@@ -13226,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]
@@ -13399,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]
@@ -13597,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]
@@ -13690,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
       []
@@ -13761,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
       []
@@ -13868,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
       []
@@ -13941,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
       []
@@ -14023,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]
@@ -14124,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]
@@ -14242,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]
@@ -14360,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]
@@ -14471,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]
@@ -14593,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]
@@ -14736,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]
@@ -14837,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]
@@ -14972,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]
@@ -15102,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]
@@ -15185,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]
@@ -15304,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
       []
@@ -15405,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
       []
@@ -15477,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
       []
@@ -15665,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
       []
@@ -15759,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
       []
@@ -15840,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]
@@ -15947,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]
@@ -16110,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
       []
@@ -16227,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
       []
@@ -16297,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]
@@ -16390,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
       []
@@ -16460,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]
@@ -16554,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]
@@ -16695,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
       []
@@ -16764,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
       []
@@ -16857,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
       []
@@ -16927,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]
@@ -17021,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]
@@ -17104,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
       []
@@ -17276,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]
@@ -17431,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
       []
@@ -17594,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
       []
@@ -17664,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]
@@ -17765,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]
@@ -17951,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]
@@ -18111,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]
@@ -18243,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]
@@ -18401,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
       []
@@ -18545,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]