prism 0.27.0 → 0.28.0

data/lib/prism/node.rb

@@ -48,11 +48,27 @@ module Prism
       end
     end
 
+    # Returns all of the lines of the source code associated with this node.
+    def source_lines
+      location.source_lines
+    end
+
+    # An alias for source_lines, used to mimic the API from
+    # RubyVM::AbstractSyntaxTree to make it easier to migrate.
+    alias script_lines source_lines
+
     # Slice the location of the node from the source.
     def slice
       location.slice
     end
 
+    # Slice the location of the node from the source, starting at the beginning
+    # of the line that the location starts on, ending at the end of the line
+    # that the location ends on.
+    def slice_lines
+      location.slice_lines
+    end
+
     # Similar to inspect, but respects the current level of indentation given by
     # the pretty print object.
     def pretty_print(q)
@@ -68,6 +84,43 @@ module Prism
       DotVisitor.new.tap { |visitor| accept(visitor) }.to_dot
     end
 
+    # Returns a list of nodes that are descendants of this node that contain the
+    # given line and column. This is useful for locating a node that is selected
+    # based on the line and column of the source code.
+    #
+    # Important to note is that the column given to this method should be in
+    # bytes, as opposed to characters or code units.
+    def tunnel(line, column)
+      queue = [self] #: Array[Prism::node]
+      result = []
+
+      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
+            queue << child_node
+            break
+          end
+        end
+      end
+
+      result
+    end
+
     # 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
     # things like recursively visiting each node _and_ field in the tree.
@@ -118,7 +171,7 @@ module Prism
     end
 
     # Returns a string representation of the node.
-    def inspect(inspector = NodeInspector.new)
+    def inspect
       raise NoMethodError, "undefined method `inspect' for #{inspect}"
     end
 
@@ -203,15 +256,9 @@ module Prism
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── new_name:\n"
-      inspector << inspector.child_node(new_name, "│   ")
-      inspector << "├── old_name:\n"
-      inspector << inspector.child_node(old_name, "│   ")
-      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -318,15 +365,9 @@ module Prism
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── new_name:\n"
-      inspector << inspector.child_node(new_name, "│   ")
-      inspector << "├── old_name:\n"
-      inspector << inspector.child_node(old_name, "│   ")
-      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -433,15 +474,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── left:\n"
-      inspector << inspector.child_node(left, "│   ")
-      inspector << "├── right:\n"
-      inspector << inspector.child_node(right, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -563,15 +598,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── left:\n"
-      inspector << inspector.child_node(left, "│   ")
-      inspector << "├── right:\n"
-      inspector << inspector.child_node(right, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -666,18 +695,19 @@ module Prism
     # attr_reader arguments: Array[Prism::node]
     attr_reader :arguments
 
+    # def contains_keywords?: () -> bool
+    def contains_keywords?
+      flags.anybits?(ArgumentsNodeFlags::CONTAINS_KEYWORDS)
+    end
+
     # def contains_keyword_splat?: () -> bool
     def contains_keyword_splat?
       flags.anybits?(ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("contains_keyword_splat" if contains_keyword_splat?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "└── arguments: #{inspector.list("#{inspector.prefix}    ", arguments)}"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -825,15 +855,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("contains_splat" if contains_splat?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── elements: #{inspector.list("#{inspector.prefix}│   ", elements)}"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -992,26 +1016,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (constant = self.constant).nil?
-        inspector << "├── constant: ∅\n"
-      else
-        inspector << "├── constant:\n"
-        inspector << constant.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── requireds: #{inspector.list("#{inspector.prefix}│   ", requireds)}"
-      if (rest = self.rest).nil?
-        inspector << "├── rest: ∅\n"
-      else
-        inspector << "├── rest:\n"
-        inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── posts: #{inspector.list("#{inspector.prefix}│   ", posts)}"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -1147,15 +1154,9 @@ module Prism
       operator_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── key:\n"
-      inspector << inspector.child_node(key, "│   ")
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -1266,17 +1267,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (value = self.value).nil?
-        inspector << "├── value: ∅\n"
-      else
-        inspector << "├── value:\n"
-        inspector << value.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -1369,11 +1362,9 @@ module Prism
     #     $+ # name `:$+`
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -1522,36 +1513,9 @@ module Prism
       end_keyword_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── begin_keyword_loc: #{inspector.location(begin_keyword_loc)}\n"
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (rescue_clause = self.rescue_clause).nil?
-        inspector << "├── rescue_clause: ∅\n"
-      else
-        inspector << "├── rescue_clause:\n"
-        inspector << rescue_clause.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (else_clause = self.else_clause).nil?
-        inspector << "├── else_clause: ∅\n"
-      else
-        inspector << "├── else_clause:\n"
-        inspector << else_clause.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (ensure_clause = self.ensure_clause).nil?
-        inspector << "├── ensure_clause: ∅\n"
-      else
-        inspector << "├── ensure_clause:\n"
-        inspector << ensure_clause.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -1659,17 +1623,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (expression = self.expression).nil?
-        inspector << "├── expression: ∅\n"
-      else
-        inspector << "├── expression:\n"
-        inspector << expression.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -1768,13 +1724,9 @@ module Prism
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("repeated_parameter" if repeated_parameter?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -1900,25 +1852,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── locals: #{locals.inspect}\n"
-      if (parameters = self.parameters).nil?
-        inspector << "├── parameters: ∅\n"
-      else
-        inspector << "├── parameters:\n"
-        inspector << parameters.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (body = self.body).nil?
-        inspector << "├── body: ∅\n"
-      else
-        inspector << "├── body:\n"
-        inspector << body.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -2049,19 +1985,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("repeated_parameter" if repeated_parameter?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (name = self.name).nil?
-        inspector << "├── name: ∅\n"
-      else
-        inspector << "├── name: #{name.inspect}\n"
-      end
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -2201,19 +2127,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (parameters = self.parameters).nil?
-        inspector << "├── parameters: ∅\n"
-      else
-        inspector << "├── parameters:\n"
-        inspector << parameters.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── locals: #{inspector.list("#{inspector.prefix}│   ", locals)}"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -2326,17 +2242,9 @@ module Prism
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -2516,25 +2424,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
-      inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── read_name: #{read_name.inspect}\n"
-      inspector << "├── write_name: #{write_name.inspect}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -2770,35 +2662,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      if (block = self.block).nil?
-        inspector << "└── block: ∅\n"
-      else
-        inspector << "└── block:\n"
-        inspector << block.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -2984,26 +2850,9 @@ module Prism
       message_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
-      inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── read_name: #{read_name.inspect}\n"
-      inspector << "├── write_name: #{write_name.inspect}\n"
-      inspector << "├── operator: #{operator.inspect}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -3190,25 +3039,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
-      inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── read_name: #{read_name.inspect}\n"
-      inspector << "├── write_name: #{write_name.inspect}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -3366,17 +3199,9 @@ module Prism
       message_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── receiver:\n"
-      inspector << inspector.child_node(receiver, "│   ")
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "└── message_loc: #{inspector.location(message_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -3485,15 +3310,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "├── target:\n"
-      inspector << inspector.child_node(target, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -3623,25 +3442,9 @@ module Prism
       end_keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (predicate = self.predicate).nil?
-        inspector << "├── predicate: ∅\n"
-      else
-        inspector << "├── predicate:\n"
-        inspector << predicate.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── conditions: #{inspector.list("#{inspector.prefix}│   ", conditions)}"
-      if (consequent = self.consequent).nil?
-        inspector << "├── consequent: ∅\n"
-      else
-        inspector << "├── consequent:\n"
-        inspector << consequent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── case_keyword_loc: #{inspector.location(case_keyword_loc)}\n"
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -3774,25 +3577,9 @@ module Prism
       end_keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (predicate = self.predicate).nil?
-        inspector << "├── predicate: ∅\n"
-      else
-        inspector << "├── predicate:\n"
-        inspector << predicate.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── conditions: #{inspector.list("#{inspector.prefix}│   ", conditions)}"
-      if (consequent = self.consequent).nil?
-        inspector << "├── consequent: ∅\n"
-      else
-        inspector << "├── consequent:\n"
-        inspector << consequent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── case_keyword_loc: #{inspector.location(case_keyword_loc)}\n"
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -3950,29 +3737,9 @@ module Prism
       end_keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── locals: #{locals.inspect}\n"
-      inspector << "├── class_keyword_loc: #{inspector.location(class_keyword_loc)}\n"
-      inspector << "├── constant_path:\n"
-      inspector << inspector.child_node(constant_path, "│   ")
-      inspector << "├── inheritance_operator_loc: #{inspector.location(inheritance_operator_loc)}\n"
-      if (superclass = self.superclass).nil?
-        inspector << "├── superclass: ∅\n"
-      else
-        inspector << "├── superclass:\n"
-        inspector << superclass.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (body = self.body).nil?
-        inspector << "├── body: ∅\n"
-      else
-        inspector << "├── body:\n"
-        inspector << body.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -4093,15 +3860,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -4216,16 +3977,9 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator: #{operator.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -4342,15 +4096,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -4445,11 +4193,9 @@ module Prism
     #     @@_test # name `:@@_test`
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -4537,11 +4283,9 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -4670,15 +4414,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -4794,15 +4532,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -4917,16 +4649,9 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator: #{operator.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5043,15 +4768,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5159,15 +4878,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── target:\n"
-      inspector << inspector.child_node(target, "│   ")
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5213,14 +4926,15 @@ module Prism
   #     Foo::Bar
   #     ^^^^^^^^
   class ConstantPathNode < Node
-    # def initialize: (Prism::node? parent, ConstantReadNode | MissingNode child, Location delimiter_loc, Location location) -> void
-    def initialize(source, parent, child, delimiter_loc, location)
+    # def initialize: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, Location location) -> void
+    def initialize(source, parent, name, delimiter_loc, name_loc, location)
       @source = source
       @newline = false
       @location = location
       @parent = parent
-      @child = child
+      @name = name
       @delimiter_loc = delimiter_loc
+      @name_loc = name_loc
     end
 
     # def accept: (Visitor visitor) -> void
@@ -5230,33 +4944,32 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [parent, child]
+      [parent]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
       compact << parent if parent
-      compact << child
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*parent, child, delimiter_loc] #: Array[Prism::node | Location]
+      [*parent, delimiter_loc, name_loc] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?parent: Prism::node?, ?child: ConstantReadNode | MissingNode, ?delimiter_loc: Location, ?location: Location) -> ConstantPathNode
-    def copy(parent: self.parent, child: self.child, delimiter_loc: self.delimiter_loc, location: self.location)
-      ConstantPathNode.new(source, parent, child, delimiter_loc, location)
+    # def copy: (?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location, ?location: Location) -> ConstantPathNode
+    def copy(parent: self.parent, name: self.name, delimiter_loc: self.delimiter_loc, name_loc: self.name_loc, location: self.location)
+      ConstantPathNode.new(source, parent, name, delimiter_loc, name_loc, location)
     end
 
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, child: ConstantReadNode | MissingNode, delimiter_loc: Location, location: Location }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location, location: Location }
     def deconstruct_keys(keys)
-      { parent: parent, child: child, delimiter_loc: delimiter_loc, location: location }
+      { parent: parent, name: name, delimiter_loc: delimiter_loc, name_loc: name_loc, location: location }
     end
 
     # The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
@@ -5271,18 +4984,8 @@ module Prism
     #     ^^^
     attr_reader :parent
 
-    # The right-hand node of the path. Always a `ConstantReadNode` in a
-    # valid Ruby syntax tree.
-    #
-    #     ::Foo
-    #       ^^^
-    #
-    #     self::Test
-    #           ^^^^
-    #
-    #     a.b::C
-    #          ^
-    attr_reader :child
+    # The name of the constant being accessed. This could be `nil` in the event of a syntax error.
+    attr_reader :name
 
     # The location of the `::` delimiter.
     #
@@ -5297,24 +5000,27 @@ module Prism
       @delimiter_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
+    # The location of the name of the constant.
+    #
+    #     ::Foo
+    #       ^^^
+    #
+    #     One::Two
+    #          ^^^
+    def name_loc
+      location = @name_loc
+      return location if location.is_a?(Location)
+      @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
+    end
+
     # def delimiter: () -> String
     def delimiter
       delimiter_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (parent = self.parent).nil?
-        inspector << "├── parent: ∅\n"
-      else
-        inspector << "├── parent:\n"
-        inspector << parent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── child:\n"
-      inspector << inspector.child_node(child, "│   ")
-      inspector << "└── delimiter_loc: #{inspector.location(delimiter_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5350,8 +5056,9 @@ module Prism
     def ===(other)
       other.is_a?(ConstantPathNode) &&
         (parent === other.parent) &&
-        (child === other.child) &&
-        (delimiter_loc.nil? == other.delimiter_loc.nil?)
+        (name === other.name) &&
+        (delimiter_loc.nil? == other.delimiter_loc.nil?) &&
+        (name_loc.nil? == other.name_loc.nil?)
     end
   end
 
@@ -5420,16 +5127,9 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── target:\n"
-      inspector << inspector.child_node(target, "│   ")
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator: #{operator.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5537,15 +5237,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── target:\n"
-      inspector << inspector.child_node(target, "│   ")
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5591,14 +5285,15 @@ module Prism
   #     Foo::Foo, Bar::Bar = baz
   #     ^^^^^^^^  ^^^^^^^^
   class ConstantPathTargetNode < Node
-    # def initialize: (Prism::node? parent, ConstantReadNode | MissingNode child, Location delimiter_loc, Location location) -> void
-    def initialize(source, parent, child, delimiter_loc, location)
+    # def initialize: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, Location location) -> void
+    def initialize(source, parent, name, delimiter_loc, name_loc, location)
       @source = source
       @newline = false
       @location = location
       @parent = parent
-      @child = child
+      @name = name
       @delimiter_loc = delimiter_loc
+      @name_loc = name_loc
     end
 
     # def accept: (Visitor visitor) -> void
@@ -5608,40 +5303,39 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [parent, child]
+      [parent]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = [] #: Array[Prism::node]
       compact << parent if parent
-      compact << child
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*parent, child, delimiter_loc] #: Array[Prism::node | Location]
+      [*parent, delimiter_loc, name_loc] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?parent: Prism::node?, ?child: ConstantReadNode | MissingNode, ?delimiter_loc: Location, ?location: Location) -> ConstantPathTargetNode
-    def copy(parent: self.parent, child: self.child, delimiter_loc: self.delimiter_loc, location: self.location)
-      ConstantPathTargetNode.new(source, parent, child, delimiter_loc, location)
+    # def copy: (?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location, ?location: Location) -> ConstantPathTargetNode
+    def copy(parent: self.parent, name: self.name, delimiter_loc: self.delimiter_loc, name_loc: self.name_loc, location: self.location)
+      ConstantPathTargetNode.new(source, parent, name, delimiter_loc, name_loc, location)
     end
 
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, child: ConstantReadNode | MissingNode, delimiter_loc: Location, location: Location }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location, location: Location }
     def deconstruct_keys(keys)
-      { parent: parent, child: child, delimiter_loc: delimiter_loc, location: location }
+      { parent: parent, name: name, delimiter_loc: delimiter_loc, name_loc: name_loc, location: location }
     end
 
     # attr_reader parent: Prism::node?
     attr_reader :parent
 
-    # attr_reader child: ConstantReadNode | MissingNode
-    attr_reader :child
+    # attr_reader name: Symbol?
+    attr_reader :name
 
     # attr_reader delimiter_loc: Location
     def delimiter_loc
@@ -5650,24 +5344,21 @@ module Prism
       @delimiter_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
+    # attr_reader name_loc: Location
+    def name_loc
+      location = @name_loc
+      return location if location.is_a?(Location)
+      @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
+    end
+
     # def delimiter: () -> String
     def delimiter
       delimiter_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (parent = self.parent).nil?
-        inspector << "├── parent: ∅\n"
-      else
-        inspector << "├── parent:\n"
-        inspector << parent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── child:\n"
-      inspector << inspector.child_node(child, "│   ")
-      inspector << "└── delimiter_loc: #{inspector.location(delimiter_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5703,8 +5394,9 @@ module Prism
     def ===(other)
       other.is_a?(ConstantPathTargetNode) &&
         (parent === other.parent) &&
-        (child === other.child) &&
-        (delimiter_loc.nil? == other.delimiter_loc.nil?)
+        (name === other.name) &&
+        (delimiter_loc.nil? == other.delimiter_loc.nil?) &&
+        (name_loc.nil? == other.name_loc.nil?)
     end
   end
 
@@ -5792,15 +5484,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── target:\n"
-      inspector << inspector.child_node(target, "│   ")
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5894,11 +5580,9 @@ module Prism
     #     SOME_CONSTANT  # name `:SOME_CONSTANT`
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -5986,11 +5670,9 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -6119,15 +5801,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -6355,37 +6031,9 @@ module Prism
       end_keyword_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (parameters = self.parameters).nil?
-        inspector << "├── parameters: ∅\n"
-      else
-        inspector << "├── parameters:\n"
-        inspector << parameters.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (body = self.body).nil?
-        inspector << "├── body: ∅\n"
-      else
-        inspector << "├── body:\n"
-        inspector << body.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── locals: #{locals.inspect}\n"
-      inspector << "├── def_keyword_loc: #{inspector.location(def_keyword_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
-      inspector << "├── rparen_loc: #{inspector.location(rparen_loc)}\n"
-      inspector << "├── equal_loc: #{inspector.location(equal_loc)}\n"
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -6536,15 +6184,9 @@ module Prism
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "├── rparen_loc: #{inspector.location(rparen_loc)}\n"
-      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -6669,18 +6311,9 @@ module Prism
       end_keyword_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── else_keyword_loc: #{inspector.location(else_keyword_loc)}\n"
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -6798,18 +6431,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -6912,13 +6536,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── variable:\n"
-      inspector << inspector.child_node(variable, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7039,18 +6659,9 @@ module Prism
       end_keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── ensure_keyword_loc: #{inspector.location(ensure_keyword_loc)}\n"
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7136,10 +6747,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7287,23 +6897,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (constant = self.constant).nil?
-        inspector << "├── constant: ∅\n"
-      else
-        inspector << "├── constant:\n"
-        inspector << constant.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── left:\n"
-      inspector << inspector.child_node(left, "│   ")
-      inspector << "├── requireds: #{inspector.list("#{inspector.prefix}│   ", requireds)}"
-      inspector << "├── right:\n"
-      inspector << inspector.child_node(right, "│   ")
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7427,25 +7023,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("exclude_end" if exclude_end?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (left = self.left).nil?
-        inspector << "├── left: ∅\n"
-      else
-        inspector << "├── left:\n"
-        inspector << left.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (right = self.right).nil?
-        inspector << "├── right: ∅\n"
-      else
-        inspector << "├── right:\n"
-        inspector << right.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7536,11 +7116,9 @@ module Prism
     # The value of the floating point number as a Float.
     attr_reader :value
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── value: #{value.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7698,24 +7276,9 @@ module Prism
       end_keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── index:\n"
-      inspector << inspector.child_node(index, "│   ")
-      inspector << "├── collection:\n"
-      inspector << inspector.child_node(collection, "│   ")
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── for_keyword_loc: #{inspector.location(for_keyword_loc)}\n"
-      inspector << "├── in_keyword_loc: #{inspector.location(in_keyword_loc)}\n"
-      inspector << "├── do_keyword_loc: #{inspector.location(do_keyword_loc)}\n"
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7807,10 +7370,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7894,10 +7456,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -7986,16 +7547,9 @@ module Prism
     # attr_reader block: BlockNode?
     attr_reader :block
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (block = self.block).nil?
-        inspector << "└── block: ∅\n"
-      else
-        inspector << "└── block:\n"
-        inspector << block.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -8108,15 +7662,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -8231,16 +7779,9 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator: #{operator.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -8357,15 +7898,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -8460,11 +7995,9 @@ module Prism
     #     $_Test # name `:$_Test`
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -8552,11 +8085,9 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -8685,15 +8216,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -8822,13 +8347,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── elements: #{inspector.list("#{inspector.prefix}│   ", elements)}"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -8972,25 +8493,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (constant = self.constant).nil?
-        inspector << "├── constant: ∅\n"
-      else
-        inspector << "├── constant:\n"
-        inspector << constant.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── elements: #{inspector.list("#{inspector.prefix}│   ", elements)}"
-      if (rest = self.rest).nil?
-        inspector << "├── rest: ∅\n"
-      else
-        inspector << "├── rest:\n"
-        inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -9208,27 +8713,9 @@ module Prism
       end_keyword_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── if_keyword_loc: #{inspector.location(if_keyword_loc)}\n"
-      inspector << "├── predicate:\n"
-      inspector << inspector.child_node(predicate, "│   ")
-      inspector << "├── then_keyword_loc: #{inspector.location(then_keyword_loc)}\n"
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (consequent = self.consequent).nil?
-        inspector << "├── consequent: ∅\n"
-      else
-        inspector << "├── consequent:\n"
-        inspector << consequent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -9321,12 +8808,9 @@ module Prism
     # attr_reader numeric: FloatNode | IntegerNode | RationalNode
     attr_reader :numeric
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── numeric:\n"
-      inspector << inspector.child_node(numeric, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -9420,12 +8904,9 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -9518,10 +8999,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -9647,20 +9127,9 @@ module Prism
       then_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── pattern:\n"
-      inspector << inspector.child_node(pattern, "│   ")
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── in_loc: #{inspector.location(in_loc)}\n"
-      inspector << "└── then_loc: #{inspector.location(then_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -9851,36 +9320,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      if (block = self.block).nil?
-        inspector << "├── block: ∅\n"
-      else
-        inspector << "├── block:\n"
-        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -10075,37 +9517,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      if (block = self.block).nil?
-        inspector << "├── block: ∅\n"
-      else
-        inspector << "├── block:\n"
-        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── operator: #{operator.inspect}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -10302,36 +9716,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      if (block = self.block).nil?
-        inspector << "├── block: ∅\n"
-      else
-        inspector << "├── block:\n"
-        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -10498,28 +9885,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?), ("ignore_visibility" if ignore_visibility?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── receiver:\n"
-      inspector << inspector.child_node(receiver, "│   ")
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      if (block = self.block).nil?
-        inspector << "└── block: ∅\n"
-      else
-        inspector << "└── block:\n"
-        inspector << block.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -10637,15 +10005,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -10760,16 +10122,9 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator: #{operator.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -10886,15 +10241,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -10989,11 +10338,9 @@ module Prism
     #     @_test # name `:@_test`
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -11081,11 +10428,9 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -11214,15 +10559,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -11338,13 +10677,9 @@ module Prism
       flags.anybits?(IntegerBaseFlags::HEXADECIMAL)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("binary" if binary?), ("decimal" if decimal?), ("octal" if octal?), ("hexadecimal" if hexadecimal?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "└── value: #{value.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -11524,15 +10859,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -11715,15 +11044,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -11873,15 +11196,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("frozen" if frozen?), ("mutable" if mutable?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -12016,13 +11333,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -12144,13 +11457,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -12237,10 +11546,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -12337,13 +11645,9 @@ module Prism
       flags.anybits?(KeywordHashNodeFlags::SYMBOL_KEYS)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("symbol_keys" if symbol_keys?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "└── elements: #{inspector.list("#{inspector.prefix}    ", elements)}"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -12471,19 +11775,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("repeated_parameter" if repeated_parameter?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (name = self.name).nil?
-        inspector << "├── name: ∅\n"
-      else
-        inspector << "├── name: #{name.inspect}\n"
-      end
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -12624,26 +11918,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── locals: #{locals.inspect}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      if (parameters = self.parameters).nil?
-        inspector << "├── parameters: ∅\n"
-      else
-        inspector << "├── parameters:\n"
-        inspector << parameters.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (body = self.body).nil?
-        inspector << "└── body: ∅\n"
-      else
-        inspector << "└── body:\n"
-        inspector << body.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -12766,16 +12043,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "└── depth: #{depth.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -12895,17 +12165,9 @@ module Prism
     # attr_reader depth: Integer
     attr_reader :depth
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── operator: #{operator.inspect}\n"
-      inspector << "└── depth: #{depth.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -13027,16 +12289,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "└── depth: #{depth.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -13150,12 +12405,9 @@ module Prism
     # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
     attr_reader :depth
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "└── depth: #{depth.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -13248,12 +12500,9 @@ module Prism
     # attr_reader depth: Integer
     attr_reader :depth
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "└── depth: #{depth.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -13397,16 +12646,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── depth: #{depth.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -13597,16 +12839,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "└── unescaped: #{unescaped.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -13715,15 +12950,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "├── pattern:\n"
-      inspector << inspector.child_node(pattern, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -13830,15 +13059,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "├── pattern:\n"
-      inspector << inspector.child_node(pattern, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -13932,13 +13155,9 @@ module Prism
     # attr_reader targets: Array[LocalVariableTargetNode]
     attr_reader :targets
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── call:\n"
-      inspector << inspector.child_node(call, "│   ")
-      inspector << "└── targets: #{inspector.list("#{inspector.prefix}    ", targets)}"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -14021,10 +13240,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -14152,22 +13370,9 @@ module Prism
       end_keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── locals: #{locals.inspect}\n"
-      inspector << "├── module_keyword_loc: #{inspector.location(module_keyword_loc)}\n"
-      inspector << "├── constant_path:\n"
-      inspector << inspector.child_node(constant_path, "│   ")
-      if (body = self.body).nil?
-        inspector << "├── body: ∅\n"
-      else
-        inspector << "├── body:\n"
-        inspector << body.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -14311,20 +13516,9 @@ module Prism
       rparen_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── lefts: #{inspector.list("#{inspector.prefix}│   ", lefts)}"
-      if (rest = self.rest).nil?
-        inspector << "├── rest: ∅\n"
-      else
-        inspector << "├── rest:\n"
-        inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── rights: #{inspector.list("#{inspector.prefix}│   ", rights)}"
-      inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
-      inspector << "└── rparen_loc: #{inspector.location(rparen_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -14486,23 +13680,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── lefts: #{inspector.list("#{inspector.prefix}│   ", lefts)}"
-      if (rest = self.rest).nil?
-        inspector << "├── rest: ∅\n"
-      else
-        inspector << "├── rest:\n"
-        inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── rights: #{inspector.list("#{inspector.prefix}│   ", rights)}"
-      inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
-      inspector << "├── rparen_loc: #{inspector.location(rparen_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -14613,17 +13793,9 @@ module Prism
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -14708,10 +13880,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -14821,12 +13992,9 @@ module Prism
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -14915,11 +14083,9 @@ module Prism
     # attr_reader maximum: Integer
     attr_reader :maximum
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── maximum: #{maximum.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -15013,11 +14179,9 @@ module Prism
     #     $4294967296 # number `0`
     attr_reader :number
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── number: #{number.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -15128,16 +14292,9 @@ module Prism
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("repeated_parameter" if repeated_parameter?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -15264,17 +14421,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("repeated_parameter" if repeated_parameter?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -15398,15 +14547,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── left:\n"
-      inspector << inspector.child_node(left, "│   ")
-      inspector << "├── right:\n"
-      inspector << inspector.child_node(right, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -15529,32 +14672,9 @@ module Prism
     # attr_reader block: BlockParameterNode?
     attr_reader :block
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── requireds: #{inspector.list("#{inspector.prefix}│   ", requireds)}"
-      inspector << "├── optionals: #{inspector.list("#{inspector.prefix}│   ", optionals)}"
-      if (rest = self.rest).nil?
-        inspector << "├── rest: ∅\n"
-      else
-        inspector << "├── rest:\n"
-        inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── posts: #{inspector.list("#{inspector.prefix}│   ", posts)}"
-      inspector << "├── keywords: #{inspector.list("#{inspector.prefix}│   ", keywords)}"
-      if (keyword_rest = self.keyword_rest).nil?
-        inspector << "├── keyword_rest: ∅\n"
-      else
-        inspector << "├── keyword_rest:\n"
-        inspector << keyword_rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (block = self.block).nil?
-        inspector << "└── block: ∅\n"
-      else
-        inspector << "└── block:\n"
-        inspector << block.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -15684,18 +14804,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (body = self.body).nil?
-        inspector << "├── body: ∅\n"
-      else
-        inspector << "├── body:\n"
-        inspector << body.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -15824,15 +14935,9 @@ module Prism
       rparen_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── expression:\n"
-      inspector << inspector.child_node(expression, "│   ")
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
-      inspector << "└── rparen_loc: #{inspector.location(rparen_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -15936,13 +15041,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── variable:\n"
-      inspector << inspector.child_node(variable, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -16072,19 +15173,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -16216,19 +15307,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -16320,13 +15401,9 @@ module Prism
     # attr_reader statements: StatementsNode
     attr_reader :statements
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── locals: #{locals.inspect}\n"
-      inspector << "└── statements:\n"
-      inspector << inspector.child_node(statements, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -16462,25 +15539,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("exclude_end" if exclude_end?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (left = self.left).nil?
-        inspector << "├── left: ∅\n"
-      else
-        inspector << "├── left:\n"
-        inspector << left.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (right = self.right).nil?
-        inspector << "├── right: ∅\n"
-      else
-        inspector << "├── right:\n"
-        inspector << right.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -16571,12 +15632,9 @@ module Prism
     # attr_reader numeric: Prism::node
     attr_reader :numeric
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── numeric:\n"
-      inspector << inspector.child_node(numeric, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -16660,10 +15718,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -16849,16 +15906,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "└── unescaped: #{unescaped.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -16969,14 +16019,9 @@ module Prism
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("repeated_parameter" if repeated_parameter?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "└── name_loc: #{inspector.location(name_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -17077,13 +16122,9 @@ module Prism
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("repeated_parameter" if repeated_parameter?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "└── name: #{name.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -17193,15 +16234,9 @@ module Prism
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── expression:\n"
-      inspector << inspector.child_node(expression, "│   ")
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "└── rescue_expression:\n"
-      inspector << inspector.child_node(rescue_expression, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -17345,31 +16380,9 @@ module Prism
       operator_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── exceptions: #{inspector.list("#{inspector.prefix}│   ", exceptions)}"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      if (reference = self.reference).nil?
-        inspector << "├── reference: ∅\n"
-      else
-        inspector << "├── reference:\n"
-        inspector << reference.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (consequent = self.consequent).nil?
-        inspector << "└── consequent: ∅\n"
-      else
-        inspector << "└── consequent:\n"
-        inspector << consequent.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -17501,19 +16514,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("repeated_parameter" if repeated_parameter?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      if (name = self.name).nil?
-        inspector << "├── name: ∅\n"
-      else
-        inspector << "├── name: #{name.inspect}\n"
-      end
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -17600,10 +16603,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -17646,11 +16648,12 @@ module Prism
   #     return 1
   #     ^^^^^^^^
   class ReturnNode < Node
-    # def initialize: (Location keyword_loc, ArgumentsNode? arguments, Location location) -> void
-    def initialize(source, keyword_loc, arguments, location)
+    # def initialize: (Integer flags, Location keyword_loc, ArgumentsNode? arguments, Location location) -> void
+    def initialize(source, flags, keyword_loc, arguments, location)
       @source = source
       @newline = false
       @location = location
+      @flags = flags
       @keyword_loc = keyword_loc
       @arguments = arguments
     end
@@ -17677,19 +16680,23 @@ module Prism
       [keyword_loc, *arguments] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?keyword_loc: Location, ?arguments: ArgumentsNode?, ?location: Location) -> ReturnNode
-    def copy(keyword_loc: self.keyword_loc, arguments: self.arguments, location: self.location)
-      ReturnNode.new(source, keyword_loc, arguments, location)
+    # def copy: (?flags: Integer, ?keyword_loc: Location, ?arguments: ArgumentsNode?, ?location: Location) -> ReturnNode
+    def copy(flags: self.flags, keyword_loc: self.keyword_loc, arguments: self.arguments, location: self.location)
+      ReturnNode.new(source, flags, keyword_loc, arguments, location)
     end
 
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, arguments: ArgumentsNode?, location: Location }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, arguments: ArgumentsNode?, location: Location }
     def deconstruct_keys(keys)
-      { keyword_loc: keyword_loc, arguments: arguments, location: location }
+      { flags: flags, keyword_loc: keyword_loc, arguments: arguments, location: location }
     end
 
+    # protected attr_reader flags: Integer
+    attr_reader :flags
+    protected :flags
+
     # attr_reader keyword_loc: Location
     def keyword_loc
       location = @keyword_loc
@@ -17700,22 +16707,19 @@ module Prism
     # attr_reader arguments: ArgumentsNode?
     attr_reader :arguments
 
+    # def redundant?: () -> bool
+    def redundant?
+      flags.anybits?(ReturnNodeFlags::REDUNDANT)
+    end
+
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "└── arguments: ∅\n"
-      else
-        inspector << "└── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -17750,6 +16754,7 @@ module Prism
     # comparing the value of locations. Locations are checked only for presence.
     def ===(other)
       other.is_a?(ReturnNode) &&
+        (flags === other.flags) &&
         (keyword_loc.nil? == other.keyword_loc.nil?) &&
         (arguments === other.arguments)
     end
@@ -17800,10 +16805,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -17911,14 +16915,9 @@ module Prism
       flags.anybits?(ShareableConstantNodeFlags::EXPERIMENTAL_COPY)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("literal" if literal?), ("experimental_everything" if experimental_everything?), ("experimental_copy" if experimental_copy?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "└── write:\n"
-      inspector << inspector.child_node(write, "    ")
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -18057,22 +17056,9 @@ module Prism
       end_keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── locals: #{locals.inspect}\n"
-      inspector << "├── class_keyword_loc: #{inspector.location(class_keyword_loc)}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "├── expression:\n"
-      inspector << inspector.child_node(expression, "│   ")
-      if (body = self.body).nil?
-        inspector << "├── body: ∅\n"
-      else
-        inspector << "├── body:\n"
-        inspector << body.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -18162,10 +17148,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -18277,13 +17262,9 @@ module Prism
       flags.anybits?(StringFlags::MUTABLE)
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("frozen" if frozen?), ("mutable" if mutable?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "└── filepath: #{filepath.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -18368,10 +17349,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -18473,17 +17453,9 @@ module Prism
       operator_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      if (expression = self.expression).nil?
-        inspector << "└── expression: ∅\n"
-      else
-        inspector << "└── expression:\n"
-        inspector << expression.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -18572,11 +17544,9 @@ module Prism
     # attr_reader body: Array[Prism::node]
     attr_reader :body
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "└── body: #{inspector.list("#{inspector.prefix}    ", body)}"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -18747,16 +17717,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("frozen" if frozen?), ("mutable" if mutable?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "└── unescaped: #{unescaped.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -18909,25 +17872,9 @@ module Prism
       rparen_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── rparen_loc: #{inspector.location(rparen_loc)}\n"
-      if (block = self.block).nil?
-        inspector << "└── block: ∅\n"
-      else
-        inspector << "└── block:\n"
-        inspector << block.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -19099,16 +18046,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── value_loc: #{inspector.location(value_loc)}\n"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "└── unescaped: #{unescaped.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -19196,10 +18136,9 @@ module Prism
       { location: location }
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -19299,12 +18238,9 @@ module Prism
       keyword_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── names: #{inspector.list("#{inspector.prefix}│   ", names)}"
-      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -19487,27 +18423,9 @@ module Prism
       end_keyword_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── predicate:\n"
-      inspector << inspector.child_node(predicate, "│   ")
-      inspector << "├── then_keyword_loc: #{inspector.location(then_keyword_loc)}\n"
-      if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
-      else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      if (consequent = self.consequent).nil?
-        inspector << "├── consequent: ∅\n"
-      else
-        inspector << "├── consequent:\n"
-        inspector << consequent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -19656,22 +18574,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("begin_modifier" if begin_modifier?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "├── predicate:\n"
-      inspector << inspector.child_node(predicate, "│   ")
-      if (statements = self.statements).nil?
-        inspector << "└── statements: ∅\n"
-      else
-        inspector << "└── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -19804,19 +18709,9 @@ module Prism
       then_keyword_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── conditions: #{inspector.list("#{inspector.prefix}│   ", conditions)}"
-      inspector << "├── then_keyword_loc: #{inspector.location(then_keyword_loc)}\n"
-      if (statements = self.statements).nil?
-        inspector << "└── statements: ∅\n"
-      else
-        inspector << "└── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -19964,22 +18859,9 @@ module Prism
       closing_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("begin_modifier" if begin_modifier?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "├── predicate:\n"
-      inspector << inspector.child_node(predicate, "│   ")
-      if (statements = self.statements).nil?
-        inspector << "└── statements: ∅\n"
-      else
-        inspector << "└── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -20125,16 +19007,9 @@ module Prism
       closing_loc.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      flags = [("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "└── unescaped: #{unescaped.inspect}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -20279,19 +19154,9 @@ module Prism
       rparen_loc&.slice
     end
 
-    # def inspect(NodeInspector inspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
-      inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "└── rparen_loc: #{inspector.location(rparen_loc)}\n"
-      inspector.to_str
+    # def inspect -> String
+    def inspect
+      InspectVisitor.compose(self)
     end
 
     # Sometimes you want to check an instance of a node against a list of
@@ -20335,8 +19200,11 @@ module Prism
 
   # Flags for arguments nodes.
   module ArgumentsNodeFlags
+    # if arguments contain keywords
+    CONTAINS_KEYWORDS = 1 << 0
+
     # if arguments contain keyword splat
-    CONTAINS_KEYWORD_SPLAT = 1 << 0
+    CONTAINS_KEYWORD_SPLAT = 1 << 1
   end
 
   # Flags for array nodes.
@@ -20453,6 +19321,12 @@ module Prism
     FORCED_US_ASCII_ENCODING = 1 << 10
   end
 
+  # Flags for return nodes.
+  module ReturnNodeFlags
+    # a return statement that is redundant because it is the last statement in a method
+    REDUNDANT = 1 << 0
+  end
+
   # Flags for shareable constant nodes.
   module ShareableConstantNodeFlags
     # constant writes that should be modified with shareable constant value literal