prism 1.7.0 → 1.8.0

data/lib/prism/node.rb

@@ -198,7 +198,7 @@ module Prism
       while (node = queue.shift)
         result << node
 
-        node.compact_child_nodes.each do |child_node|
+        node.each_child_node do |child_node|
           child_location = child_node.location
 
           start_line = child_location.start_line
@@ -270,6 +270,13 @@ module Prism
 
     alias deconstruct child_nodes
 
+    # With a block given, yields each child node. Without a block, returns
+    # an enumerator that contains each child node. Excludes any `nil`s in
+    # the place of optional nodes that were not present.
+    def each_child_node
+      raise NoMethodError, "undefined method `each_child_node' for #{inspect}"
+    end
+
     # Returns an array of child nodes, excluding any `nil`s in the place of
     # optional nodes that were not present.
     def compact_child_nodes
@@ -338,6 +345,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 +460,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 +587,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 +702,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 +821,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 +933,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 +1097,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 +1275,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 +1404,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 +1511,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 +1601,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 +1770,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 +1877,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 +1969,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]
@@ -2007,6 +2122,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 +2264,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 +2432,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 +2545,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 +2775,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 +3064,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 +3279,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 +3497,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 +3654,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 +3773,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 +3927,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 +4082,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 +4269,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 +4402,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 +4521,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 +4638,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 +4721,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 +4803,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 +4939,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 +5060,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 +5179,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 +5298,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 +5405,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 +5548,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 +5653,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 +5760,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 +5887,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 +6003,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 +6086,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 +6168,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 +6313,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 +6577,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 +6728,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 +6856,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 +6977,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 +7082,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 +7201,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 +7290,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 +7476,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 +7589,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 +7674,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 +7874,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 +7949,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 +8029,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 +8114,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 +8235,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 +8354,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 +8471,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 +8554,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 +8636,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 +8771,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 +8915,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 +9101,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 +9316,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 +9402,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 +9490,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 +9568,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 +9707,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 +9918,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 +10127,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 +10342,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 +10498,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 +10619,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 +10738,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 +10855,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 +10938,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 +11020,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 +11153,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 +11255,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 +11432,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 +11609,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 +11753,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 +11886,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 +12004,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 +12078,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 +12153,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 +12243,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 +12372,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 +12526,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 +12652,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 +12776,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 +12898,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 +12999,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 +13086,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 +13236,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 +13430,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 +13536,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 +13689,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 +13771,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 +13851,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 +13995,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 +14177,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 +14385,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 +14485,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 +14562,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 +14675,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 +14754,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 +14842,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 +14950,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 +15075,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 +15201,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 +15325,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 +15454,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 +15604,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 +15712,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 +15854,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 +15991,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 +16081,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 +16208,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 +16315,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 +16393,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 +16587,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 +16687,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 +16774,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 +16889,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 +17062,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 +17185,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 +17261,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 +17361,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 +17437,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 +17538,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 +17687,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 +17762,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 +17861,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 +17937,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 +18038,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 +18128,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 +18306,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 +18469,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 +18638,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 +18714,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 +18822,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 +19017,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 +19185,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 +19325,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 +19491,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 +19641,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]