prism 0.16.0 → 0.17.0

data/lib/prism/node.rb

@@ -9,13 +9,15 @@ module Prism
   # This represents a node in the tree. It is the parent class of all of the
   # various node types.
   class Node
+    # A Location instance that represents the location of this node in the
+    # source.
     attr_reader :location
 
-    def newline?
+    def newline? # :nodoc:
       @newline ? true : false
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       line = location.start_line
       unless newline_marked[line]
         newline_marked[line] = true
@@ -103,6 +105,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── new_name:\n"
@@ -207,6 +210,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── new_name:\n"
@@ -311,6 +315,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── left:\n"
@@ -415,6 +420,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── left:\n"
@@ -514,6 +520,7 @@ module Prism
       flags.anybits?(ArgumentsNodeFlags::KEYWORD_SPLAT)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── arguments: #{inspector.list("#{inspector.prefix}│   ", arguments)}"
@@ -622,6 +629,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── elements: #{inspector.list("#{inspector.prefix}│   ", elements)}"
@@ -761,6 +769,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (constant = self.constant).nil?
@@ -879,6 +888,7 @@ module Prism
       operator_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── key:\n"
@@ -984,6 +994,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (value = self.value).nil?
@@ -1075,6 +1086,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -1151,7 +1163,7 @@ module Prism
       visitor.visit_begin_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       # Never mark BeginNode with a newline flag, mark children instead
     end
 
@@ -1206,6 +1218,7 @@ module Prism
       end_keyword_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── begin_keyword_loc: #{inspector.location(begin_keyword_loc)}\n"
@@ -1328,6 +1341,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (expression = self.expression).nil?
@@ -1419,6 +1433,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -1537,6 +1552,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── locals: #{locals.inspect}\n"
@@ -1652,6 +1668,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (name = self.name).nil?
@@ -1775,6 +1792,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (parameters = self.parameters).nil?
@@ -1880,6 +1898,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (arguments = self.arguments).nil?
@@ -2034,6 +2053,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (receiver = self.receiver).nil?
@@ -2222,6 +2242,7 @@ module Prism
       flags.anybits?(CallNodeFlags::VARIABLE_CALL)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (receiver = self.receiver).nil?
@@ -2394,6 +2415,7 @@ module Prism
       flags.anybits?(CallNodeFlags::VARIABLE_CALL)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (receiver = self.receiver).nil?
@@ -2557,6 +2579,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (receiver = self.receiver).nil?
@@ -2671,6 +2694,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── value:\n"
@@ -2712,10 +2736,10 @@ module Prism
 
   # Represents the use of a case statement.
   #
-  # case true
-  # ^^^^^^^^^
-  # when false
-  # end
+  #     case true
+  #     when false
+  #     end
+  #     ^^^^^^^^^^
   class CaseNode < Node
     # attr_reader predicate: Node?
     attr_reader :predicate
@@ -2796,6 +2820,7 @@ module Prism
       end_keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (predicate = self.predicate).nil?
@@ -2949,6 +2974,7 @@ module Prism
       end_keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── locals: #{locals.inspect}\n"
@@ -3005,7 +3031,7 @@ module Prism
   # Represents the use of the `&&=` operator for assignment to a class variable.
   #
   #     @@target &&= value
-  #     ^^^^^^^^^^^^^^^^
+  #     ^^^^^^^^^^^^^^^^^^
   class ClassVariableAndWriteNode < Node
     # attr_reader name: Symbol
     attr_reader :name
@@ -3072,6 +3098,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -3181,6 +3208,7 @@ module Prism
       { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -3291,6 +3319,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -3380,6 +3409,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -3465,6 +3495,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -3570,6 +3601,7 @@ module Prism
       operator_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -3679,6 +3711,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -3788,6 +3821,7 @@ module Prism
       { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -3898,6 +3932,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -4002,6 +4037,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── target:\n"
@@ -4109,6 +4145,7 @@ module Prism
       delimiter_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (parent = self.parent).nil?
@@ -4217,6 +4254,7 @@ module Prism
       { target: target, operator_loc: operator_loc, value: value, operator: operator, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── target:\n"
@@ -4322,6 +4360,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── target:\n"
@@ -4429,6 +4468,7 @@ module Prism
       delimiter_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (parent = self.parent).nil?
@@ -4543,6 +4583,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── target:\n"
@@ -4632,6 +4673,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -4717,6 +4759,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -4822,6 +4865,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -5001,6 +5045,7 @@ module Prism
       end_keyword_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -5142,6 +5187,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
@@ -5253,6 +5299,7 @@ module Prism
       end_keyword_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── else_keyword_loc: #{inspector.location(else_keyword_loc)}\n"
@@ -5367,6 +5414,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -5469,6 +5517,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
@@ -5582,6 +5631,7 @@ module Prism
       end_keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── ensure_keyword_loc: #{inspector.location(ensure_keyword_loc)}\n"
@@ -5669,6 +5719,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -5706,13 +5757,13 @@ module Prism
   # Represents a find pattern in pattern matching.
   #
   #     foo in *bar, baz, *qux
-  #     ^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^
   #
   #     foo in [*bar, baz, *qux]
-  #     ^^^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^^^
   #
   #     foo in Foo(*bar, baz, *qux)
-  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^^^^^^
   class FindPatternNode < Node
     # attr_reader constant: Node?
     attr_reader :constant
@@ -5799,6 +5850,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (constant = self.constant).nil?
@@ -5924,6 +5976,7 @@ module Prism
       flags.anybits?(RangeFlags::EXCLUDE_END)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (left = self.left).nil?
@@ -6018,6 +6071,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -6156,6 +6210,7 @@ module Prism
       end_keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── index:\n"
@@ -6208,7 +6263,7 @@ module Prism
   #
   #     def foo(...)
   #       bar(...)
-  #       ^^^^^^^^
+  #           ^^^
   #     end
   class ForwardingArgumentsNode < Node
     # def initialize: (location: Location) -> void
@@ -6251,6 +6306,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -6331,6 +6387,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -6417,6 +6474,7 @@ module Prism
       { block: block, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (block = self.block).nil?
@@ -6527,6 +6585,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -6636,6 +6695,7 @@ module Prism
       { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -6746,6 +6806,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -6835,6 +6896,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -6920,6 +6982,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -7025,6 +7088,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -7134,6 +7198,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -7258,6 +7323,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (constant = self.constant).nil?
@@ -7345,7 +7411,7 @@ module Prism
       visitor.visit_if_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       predicate.set_newline_flag(newline_marked)
     end
 
@@ -7398,6 +7464,7 @@ module Prism
       end_keyword_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── if_keyword_loc: #{inspector.location(if_keyword_loc)}\n"
@@ -7498,6 +7565,7 @@ module Prism
       { numeric: numeric, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── numeric:\n"
@@ -7588,6 +7656,7 @@ module Prism
       { value: value, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── value:\n"
@@ -7702,6 +7771,7 @@ module Prism
       then_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── pattern:\n"
@@ -7871,6 +7941,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (receiver = self.receiver).nil?
@@ -8056,6 +8127,7 @@ module Prism
       flags.anybits?(CallNodeFlags::VARIABLE_CALL)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (receiver = self.receiver).nil?
@@ -8242,6 +8314,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (receiver = self.receiver).nil?
@@ -8372,6 +8445,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -8481,6 +8555,7 @@ module Prism
       { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -8591,6 +8666,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -8680,6 +8756,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -8765,6 +8842,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -8870,6 +8948,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -8979,6 +9058,7 @@ module Prism
       flags.anybits?(IntegerBaseFlags::HEXADECIMAL)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       flags = [("binary" if binary?), ("octal" if octal?), ("decimal" if decimal?), ("hexadecimal" if hexadecimal?)].compact
@@ -9048,7 +9128,7 @@ module Prism
       visitor.visit_interpolated_match_last_line_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       first = parts.first
       first.set_newline_flag(newline_marked) if first
     end
@@ -9137,6 +9217,7 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -9207,7 +9288,7 @@ module Prism
       visitor.visit_interpolated_regular_expression_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       first = parts.first
       first.set_newline_flag(newline_marked) if first
     end
@@ -9296,6 +9377,7 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -9362,7 +9444,7 @@ module Prism
       visitor.visit_interpolated_string_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       first = parts.first
       first.set_newline_flag(newline_marked) if first
     end
@@ -9410,6 +9492,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -9474,7 +9557,7 @@ module Prism
       visitor.visit_interpolated_symbol_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       first = parts.first
       first.set_newline_flag(newline_marked) if first
     end
@@ -9522,6 +9605,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -9586,7 +9670,7 @@ module Prism
       visitor.visit_interpolated_x_string_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       first = parts.first
       first.set_newline_flag(newline_marked) if first
     end
@@ -9634,6 +9718,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -9721,6 +9806,7 @@ module Prism
       { elements: elements, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── elements: #{inspector.list("#{inspector.prefix}    ", elements)}"
@@ -9756,115 +9842,6 @@ module Prism
     end
   end
 
-  # Represents a keyword parameter to a method, block, or lambda definition.
-  #
-  #     def a(b:)
-  #           ^^
-  #     end
-  #
-  #     def a(b: 1)
-  #           ^^^^
-  #     end
-  class KeywordParameterNode < Node
-    # attr_reader name: Symbol
-    attr_reader :name
-
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-
-    # attr_reader value: Node?
-    attr_reader :value
-
-    # def initialize: (name: Symbol, name_loc: Location, value: Node?, location: Location) -> void
-    def initialize(name, name_loc, value, location)
-      @name = name
-      @name_loc = name_loc
-      @value = value
-      @location = location
-    end
-
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_keyword_parameter_node(self)
-    end
-
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [value]
-    end
-
-    # def compact_child_nodes: () -> Array[Node]
-    def compact_child_nodes
-      compact = []
-      compact << value if value
-      compact
-    end
-
-    # def comment_targets: () -> Array[Node | Location]
-    def comment_targets
-      [name_loc, *value]
-    end
-
-    # def copy: (**params) -> KeywordParameterNode
-    def copy(**params)
-      KeywordParameterNode.new(
-        params.fetch(:name) { name },
-        params.fetch(:name_loc) { name_loc },
-        params.fetch(:value) { value },
-        params.fetch(:location) { location },
-      )
-    end
-
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { name: name, name_loc: name_loc, value: value, location: location }
-    end
-
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
-      if (value = self.value).nil?
-        inspector << "└── value: ∅\n"
-      else
-        inspector << "└── value:\n"
-        inspector << value.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
-      end
-      inspector.to_str
-    end
-
-    # Sometimes you want to check an instance of a node against a list of
-    # classes to see what kind of behavior to perform. Usually this is done by
-    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-    # case statement and doing `case node; when cls1; when cls2; end`. Both of
-    # these approaches are relatively slow because of the constant lookups,
-    # method calls, and/or array allocations.
-    #
-    # Instead, you can call #type, which will return to you a symbol that you
-    # can use for comparison. This is faster than the other approaches because
-    # it uses a single integer comparison, but also because if you're on CRuby
-    # you can take advantage of the fact that case statements with all symbol
-    # keys will use a jump table.
-    #
-    # def type: () -> Symbol
-    def type
-      :keyword_parameter_node
-    end
-
-    # Similar to #type, this method returns a symbol that you can use for
-    # splitting on the type of the node without having to do a long === chain.
-    # Note that like #type, it will still be slower than using == for a single
-    # class, but should be faster in a case statement or an array comparison.
-    #
-    # def self.type: () -> Symbol
-    def self.type
-      :keyword_parameter_node
-    end
-  end
-
   # Represents a keyword rest parameter to a method, block, or lambda definition.
   #
   #     def a(**b)
@@ -9931,6 +9908,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (name = self.name).nil?
@@ -10065,6 +10043,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── locals: #{locals.inspect}\n"
@@ -10190,6 +10169,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
@@ -10305,6 +10285,7 @@ module Prism
       { name_loc: name_loc, operator_loc: operator_loc, value: value, name: name, operator: operator, depth: depth, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
@@ -10421,6 +10402,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
@@ -10518,6 +10500,7 @@ module Prism
       { name: name, depth: depth, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -10609,6 +10592,7 @@ module Prism
       { name: name, depth: depth, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -10720,6 +10704,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -10887,6 +10872,7 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -10992,6 +10978,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── value:\n"
@@ -11096,6 +11083,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── value:\n"
@@ -11191,6 +11179,7 @@ module Prism
       { call: call, locals: locals, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── call:\n"
@@ -11271,6 +11260,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -11393,6 +11383,7 @@ module Prism
       end_keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── locals: #{locals.inspect}\n"
@@ -11523,6 +11514,7 @@ module Prism
       rparen_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── lefts: #{inspector.list("#{inspector.prefix}│   ", lefts)}"
@@ -11667,6 +11659,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── lefts: #{inspector.list("#{inspector.prefix}│   ", lefts)}"
@@ -11776,6 +11769,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (arguments = self.arguments).nil?
@@ -11862,6 +11856,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -11962,6 +11957,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
@@ -12048,6 +12044,7 @@ module Prism
       { number: number, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── number: #{number.inspect}\n"
@@ -12083,6 +12080,106 @@ module Prism
     end
   end
 
+  # Represents an optional keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: 1)
+  #           ^^^^
+  #     end
+  class OptionalKeywordParameterNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # attr_reader name_loc: Location
+    attr_reader :name_loc
+
+    # attr_reader value: Node
+    attr_reader :value
+
+    # def initialize: (name: Symbol, name_loc: Location, value: Node, location: Location) -> void
+    def initialize(name, name_loc, value, location)
+      @name = name
+      @name_loc = name_loc
+      @value = value
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_optional_keyword_parameter_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [value]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      [value]
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [name_loc, value]
+    end
+
+    # def copy: (**params) -> OptionalKeywordParameterNode
+    def copy(**params)
+      OptionalKeywordParameterNode.new(
+        params.fetch(:name) { name },
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { name: name, name_loc: name_loc, value: value, location: location }
+    end
+
+    # def inspect(inspector: NodeInspector) -> 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.to_str
+    end
+
+    # Sometimes you want to check an instance of a node against a list of
+    # classes to see what kind of behavior to perform. Usually this is done by
+    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+    # case statement and doing `case node; when cls1; when cls2; end`. Both of
+    # these approaches are relatively slow because of the constant lookups,
+    # method calls, and/or array allocations.
+    #
+    # Instead, you can call #type, which will return to you a symbol that you
+    # can use for comparison. This is faster than the other approaches because
+    # it uses a single integer comparison, but also because if you're on CRuby
+    # you can take advantage of the fact that case statements with all symbol
+    # keys will use a jump table.
+    #
+    # def type: () -> Symbol
+    def type
+      :optional_keyword_parameter_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :optional_keyword_parameter_node
+    end
+  end
+
   # Represents an optional parameter to a method, block, or lambda definition.
   #
   #     def a(b = 1)
@@ -12154,6 +12251,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── name: #{name.inspect}\n"
@@ -12258,6 +12356,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── left:\n"
@@ -12386,6 +12485,7 @@ module Prism
       { requireds: requireds, optionals: optionals, rest: rest, posts: posts, keywords: keywords, keyword_rest: keyword_rest, block: block, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── requireds: #{inspector.list("#{inspector.prefix}│   ", requireds)}"
@@ -12469,7 +12569,7 @@ module Prism
       visitor.visit_parentheses_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       # Never mark ParenthesesNode with a newline flag, mark children instead
     end
 
@@ -12518,6 +12618,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (body = self.body).nil?
@@ -12641,6 +12742,7 @@ module Prism
       rparen_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── expression:\n"
@@ -12741,6 +12843,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── variable:\n"
@@ -12860,6 +12963,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (statements = self.statements).nil?
@@ -12985,6 +13089,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (statements = self.statements).nil?
@@ -13080,6 +13185,7 @@ module Prism
       { locals: locals, statements: statements, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── locals: #{locals.inspect}\n"
@@ -13198,6 +13304,7 @@ module Prism
       flags.anybits?(RangeFlags::EXCLUDE_END)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (left = self.left).nil?
@@ -13297,6 +13404,7 @@ module Prism
       { numeric: numeric, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── numeric:\n"
@@ -13378,6 +13486,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -13537,6 +13646,7 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -13577,6 +13687,99 @@ module Prism
     end
   end
 
+  # Represents a required keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: )
+  #           ^^
+  #     end
+  class RequiredKeywordParameterNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # attr_reader name_loc: Location
+    attr_reader :name_loc
+
+    # def initialize: (name: Symbol, name_loc: Location, location: Location) -> void
+    def initialize(name, name_loc, location)
+      @name = name
+      @name_loc = name_loc
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_required_keyword_parameter_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      []
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      []
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [name_loc]
+    end
+
+    # def copy: (**params) -> RequiredKeywordParameterNode
+    def copy(**params)
+      RequiredKeywordParameterNode.new(
+        params.fetch(:name) { name },
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { name: name, name_loc: name_loc, location: location }
+    end
+
+    # def inspect(inspector: NodeInspector) -> String
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      inspector << "├── name: #{name.inspect}\n"
+      inspector << "└── name_loc: #{inspector.location(name_loc)}\n"
+      inspector.to_str
+    end
+
+    # Sometimes you want to check an instance of a node against a list of
+    # classes to see what kind of behavior to perform. Usually this is done by
+    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+    # case statement and doing `case node; when cls1; when cls2; end`. Both of
+    # these approaches are relatively slow because of the constant lookups,
+    # method calls, and/or array allocations.
+    #
+    # Instead, you can call #type, which will return to you a symbol that you
+    # can use for comparison. This is faster than the other approaches because
+    # it uses a single integer comparison, but also because if you're on CRuby
+    # you can take advantage of the fact that case statements with all symbol
+    # keys will use a jump table.
+    #
+    # def type: () -> Symbol
+    def type
+      :required_keyword_parameter_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :required_keyword_parameter_node
+    end
+  end
+
   # Represents a required parameter to a method, block, or lambda definition.
   #
   #     def a(b)
@@ -13628,6 +13831,7 @@ module Prism
       { name: name, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── name: #{name.inspect}\n"
@@ -13665,8 +13869,8 @@ module Prism
 
   # Represents an expression modified with a rescue.
   #
-  #   foo rescue nil
-  #   ^^^^^^^^^^^^^^
+  #     foo rescue nil
+  #     ^^^^^^^^^^^^^^
   class RescueModifierNode < Node
     # attr_reader expression: Node
     attr_reader :expression
@@ -13690,7 +13894,7 @@ module Prism
       visitor.visit_rescue_modifier_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       expression.set_newline_flag(newline_marked)
     end
 
@@ -13732,6 +13936,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── expression:\n"
@@ -13775,8 +13980,8 @@ module Prism
   #
   #     begin
   #     rescue Foo, *splat, Bar => ex
-  #     ^^^^^^
   #       foo
+  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   #     end
   #
   # `Foo, *splat, Bar` are in the `exceptions` field.
@@ -13867,6 +14072,7 @@ module Prism
       operator_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
@@ -13988,6 +14194,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       if (name = self.name).nil?
@@ -14074,6 +14281,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -14170,6 +14378,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
@@ -14256,6 +14465,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -14383,6 +14593,7 @@ module Prism
       end_keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── locals: #{locals.inspect}\n"
@@ -14474,6 +14685,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -14558,6 +14770,7 @@ module Prism
       { filepath: filepath, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── filepath: #{filepath.inspect}\n"
@@ -14638,6 +14851,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -14734,6 +14948,7 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
@@ -14825,6 +15040,7 @@ module Prism
       { body: body, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "└── body: #{inspector.list("#{inspector.prefix}    ", body)}"
@@ -14915,6 +15131,7 @@ module Prism
       { left: left, right: right, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── left:\n"
@@ -15050,6 +15267,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       flags = [("frozen" if frozen?)].compact
@@ -15181,6 +15399,7 @@ module Prism
       rparen_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
@@ -15313,6 +15532,7 @@ module Prism
       closing_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -15396,6 +15616,7 @@ module Prism
       { location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector.to_str
@@ -15490,6 +15711,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── names: #{inspector.list("#{inspector.prefix}│   ", names)}"
@@ -15564,7 +15786,7 @@ module Prism
       visitor.visit_unless_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       predicate.set_newline_flag(newline_marked)
     end
 
@@ -15617,6 +15839,7 @@ module Prism
       end_keyword_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
@@ -15705,7 +15928,7 @@ module Prism
       visitor.visit_until_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       predicate.set_newline_flag(newline_marked)
     end
 
@@ -15762,6 +15985,7 @@ module Prism
       flags.anybits?(LoopFlags::BEGIN_MODIFIER)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
@@ -15878,6 +16102,7 @@ module Prism
       keyword_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
@@ -15958,7 +16183,7 @@ module Prism
       visitor.visit_while_node(self)
     end
 
-    def set_newline_flag(newline_marked)
+    def set_newline_flag(newline_marked) # :nodoc:
       predicate.set_newline_flag(newline_marked)
     end
 
@@ -16015,6 +16240,7 @@ module Prism
       flags.anybits?(LoopFlags::BEGIN_MODIFIER)
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
@@ -16141,6 +16367,7 @@ module Prism
       closing_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
@@ -16261,6 +16488,7 @@ module Prism
       rparen_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
@@ -16304,11 +16532,13 @@ module Prism
     end
   end
 
+  # Flags for arguments nodes.
   module ArgumentsNodeFlags
     # if arguments contain keyword splat
     KEYWORD_SPLAT = 1 << 0
   end
 
+  # Flags for call nodes.
   module CallNodeFlags
     # &. operator
     SAFE_NAVIGATION = 1 << 0
@@ -16317,6 +16547,7 @@ module Prism
     VARIABLE_CALL = 1 << 1
   end
 
+  # Flags for integer nodes that correspond to the base of the integer.
   module IntegerBaseFlags
     # 0b prefix
     BINARY = 1 << 0
@@ -16331,16 +16562,19 @@ module Prism
     HEXADECIMAL = 1 << 3
   end
 
+  # Flags for while and until loop nodes.
   module LoopFlags
     # a loop after a begin statement, so the body is executed first before the condition
     BEGIN_MODIFIER = 1 << 0
   end
 
+  # Flags for range and flip-flop nodes.
   module RangeFlags
     # ... operator
     EXCLUDE_END = 1 << 0
   end
 
+  # Flags for regular expression and match last line nodes.
   module RegularExpressionFlags
     # i - ignores the case of characters when matching
     IGNORE_CASE = 1 << 0
@@ -16367,6 +16601,7 @@ module Prism
     UTF_8 = 1 << 7
   end
 
+  # Flags for string nodes.
   module StringFlags
     # frozen by virtue of a `frozen_string_literal` comment
     FROZEN = 1 << 0