prism 0.15.1 → 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"
@@ -462,9 +468,13 @@ module Prism
     # attr_reader arguments: Array[Node]
     attr_reader :arguments
 
-    # def initialize: (arguments: Array[Node], location: Location) -> void
-    def initialize(arguments, location)
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
+    # def initialize: (arguments: Array[Node], flags: Integer, location: Location) -> void
+    def initialize(arguments, flags, location)
       @arguments = arguments
+      @flags = flags
       @location = location
     end
 
@@ -492,6 +502,7 @@ module Prism
     def copy(**params)
       ArgumentsNode.new(
         params.fetch(:arguments) { arguments },
+        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -501,12 +512,20 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { arguments: arguments, location: location }
+      { arguments: arguments, flags: flags, location: location }
     end
 
+    # def keyword_splat?: () -> bool
+    def keyword_splat?
+      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)}"
+      inspector << "├── arguments: #{inspector.list("#{inspector.prefix}│   ", arguments)}"
+      flags = [("keyword_splat" if keyword_splat?)].compact
+      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
 
@@ -610,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)}"
@@ -749,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?
@@ -867,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"
@@ -972,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?
@@ -1063,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"
@@ -1139,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
 
@@ -1194,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"
@@ -1316,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?
@@ -1407,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"
@@ -1525,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"
@@ -1640,9 +1668,14 @@ 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"
+      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
@@ -1759,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?
@@ -1864,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?
@@ -2018,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?
@@ -2206,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?
@@ -2378,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?
@@ -2541,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?
@@ -2655,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"
@@ -2696,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
@@ -2780,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?
@@ -2933,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"
@@ -2989,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
@@ -3056,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"
@@ -3165,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"
@@ -3275,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"
@@ -3364,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"
@@ -3449,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"
@@ -3554,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"
@@ -3663,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"
@@ -3772,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"
@@ -3882,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"
@@ -3986,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"
@@ -4093,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?
@@ -4201,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"
@@ -4306,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"
@@ -4413,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?
@@ -4527,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"
@@ -4616,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"
@@ -4701,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"
@@ -4806,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"
@@ -4985,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"
@@ -5126,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"
@@ -5237,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"
@@ -5351,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"
@@ -5453,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"
@@ -5566,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"
@@ -5653,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
@@ -5690,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
@@ -5783,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?
@@ -5908,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?
@@ -6002,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
@@ -6140,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"
@@ -6192,7 +6263,7 @@ module Prism
   #
   #     def foo(...)
   #       bar(...)
-  #       ^^^^^^^^
+  #           ^^^
   #     end
   class ForwardingArgumentsNode < Node
     # def initialize: (location: Location) -> void
@@ -6235,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
@@ -6315,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
@@ -6401,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?
@@ -6511,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"
@@ -6620,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"
@@ -6730,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"
@@ -6819,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"
@@ -6904,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"
@@ -7009,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"
@@ -7118,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"
@@ -7166,11 +7247,11 @@ module Prism
     # attr_reader constant: Node?
     attr_reader :constant
 
-    # attr_reader assocs: Array[Node]
-    attr_reader :assocs
+    # attr_reader elements: Array[Node]
+    attr_reader :elements
 
-    # attr_reader kwrest: Node?
-    attr_reader :kwrest
+    # attr_reader rest: Node?
+    attr_reader :rest
 
     # attr_reader opening_loc: Location?
     attr_reader :opening_loc
@@ -7178,11 +7259,11 @@ module Prism
     # attr_reader closing_loc: Location?
     attr_reader :closing_loc
 
-    # def initialize: (constant: Node?, assocs: Array[Node], kwrest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
-    def initialize(constant, assocs, kwrest, opening_loc, closing_loc, location)
+    # def initialize: (constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    def initialize(constant, elements, rest, opening_loc, closing_loc, location)
       @constant = constant
-      @assocs = assocs
-      @kwrest = kwrest
+      @elements = elements
+      @rest = rest
       @opening_loc = opening_loc
       @closing_loc = closing_loc
       @location = location
@@ -7195,29 +7276,29 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [constant, *assocs, kwrest]
+      [constant, *elements, rest]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = []
       compact << constant if constant
-      compact.concat(assocs)
-      compact << kwrest if kwrest
+      compact.concat(elements)
+      compact << rest if rest
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*constant, *assocs, *kwrest, *opening_loc, *closing_loc]
+      [*constant, *elements, *rest, *opening_loc, *closing_loc]
     end
 
     # def copy: (**params) -> HashPatternNode
     def copy(**params)
       HashPatternNode.new(
         params.fetch(:constant) { constant },
-        params.fetch(:assocs) { assocs },
-        params.fetch(:kwrest) { kwrest },
+        params.fetch(:elements) { elements },
+        params.fetch(:rest) { rest },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:location) { location },
@@ -7229,7 +7310,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { constant: constant, assocs: assocs, kwrest: kwrest, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
+      { constant: constant, elements: elements, rest: rest, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
     end
 
     # def opening: () -> String?
@@ -7242,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?
@@ -7250,12 +7332,12 @@ module Prism
         inspector << "├── constant:\n"
         inspector << constant.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
-      inspector << "├── assocs: #{inspector.list("#{inspector.prefix}│   ", assocs)}"
-      if (kwrest = self.kwrest).nil?
-        inspector << "├── kwrest: ∅\n"
+      inspector << "├── elements: #{inspector.list("#{inspector.prefix}│   ", elements)}"
+      if (rest = self.rest).nil?
+        inspector << "├── rest: ∅\n"
       else
-        inspector << "├── kwrest:\n"
-        inspector << kwrest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+        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"
@@ -7329,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
 
@@ -7382,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"
@@ -7482,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"
@@ -7572,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"
@@ -7686,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"
@@ -7855,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?
@@ -8040,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?
@@ -8226,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?
@@ -8356,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"
@@ -8465,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"
@@ -8575,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"
@@ -8664,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"
@@ -8749,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"
@@ -8854,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"
@@ -8963,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
@@ -9032,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
@@ -9121,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"
@@ -9191,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
@@ -9280,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"
@@ -9346,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
@@ -9394,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"
@@ -9458,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
@@ -9506,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"
@@ -9570,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
@@ -9618,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"
@@ -9705,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)}"
@@ -9740,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)
@@ -9915,9 +9908,14 @@ 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"
+      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
@@ -10045,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"
@@ -10170,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"
@@ -10285,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"
@@ -10401,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"
@@ -10498,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"
@@ -10589,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"
@@ -10700,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"
@@ -10867,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"
@@ -10972,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"
@@ -11076,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"
@@ -11171,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"
@@ -11251,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
@@ -11373,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"
@@ -11421,11 +11432,17 @@ module Prism
 
   # Represents a multi-target expression.
   #
-  #     a, b, c = 1, 2, 3
-  #     ^^^^^^^
+  #     a, (b, c) = 1, 2, 3
+  #        ^^^^^^
   class MultiTargetNode < Node
-    # attr_reader targets: Array[Node]
-    attr_reader :targets
+    # attr_reader lefts: Array[Node]
+    attr_reader :lefts
+
+    # attr_reader rest: Node?
+    attr_reader :rest
+
+    # attr_reader rights: Array[Node]
+    attr_reader :rights
 
     # attr_reader lparen_loc: Location?
     attr_reader :lparen_loc
@@ -11433,9 +11450,11 @@ module Prism
     # attr_reader rparen_loc: Location?
     attr_reader :rparen_loc
 
-    # def initialize: (targets: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void
-    def initialize(targets, lparen_loc, rparen_loc, location)
-      @targets = targets
+    # def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void
+    def initialize(lefts, rest, rights, lparen_loc, rparen_loc, location)
+      @lefts = lefts
+      @rest = rest
+      @rights = rights
       @lparen_loc = lparen_loc
       @rparen_loc = rparen_loc
       @location = location
@@ -11448,23 +11467,29 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [*targets]
+      [*lefts, rest, *rights]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [*targets]
+      compact = []
+      compact.concat(lefts)
+      compact << rest if rest
+      compact.concat(rights)
+      compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*targets, *lparen_loc, *rparen_loc]
+      [*lefts, *rest, *rights, *lparen_loc, *rparen_loc]
     end
 
     # def copy: (**params) -> MultiTargetNode
     def copy(**params)
       MultiTargetNode.new(
-        params.fetch(:targets) { targets },
+        params.fetch(:lefts) { lefts },
+        params.fetch(:rest) { rest },
+        params.fetch(:rights) { rights },
         params.fetch(:lparen_loc) { lparen_loc },
         params.fetch(:rparen_loc) { rparen_loc },
         params.fetch(:location) { location },
@@ -11476,7 +11501,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { targets: targets, lparen_loc: lparen_loc, rparen_loc: rparen_loc, location: location }
+      { lefts: lefts, rest: rest, rights: rights, lparen_loc: lparen_loc, rparen_loc: rparen_loc, location: location }
     end
 
     # def lparen: () -> String?
@@ -11489,9 +11514,17 @@ module Prism
       rparen_loc&.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── targets: #{inspector.list("#{inspector.prefix}│   ", targets)}"
+      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
@@ -11531,8 +11564,14 @@ module Prism
   #     a, b, c = 1, 2, 3
   #     ^^^^^^^^^^^^^^^^^
   class MultiWriteNode < Node
-    # attr_reader targets: Array[Node]
-    attr_reader :targets
+    # attr_reader lefts: Array[Node]
+    attr_reader :lefts
+
+    # attr_reader rest: Node?
+    attr_reader :rest
+
+    # attr_reader rights: Array[Node]
+    attr_reader :rights
 
     # attr_reader lparen_loc: Location?
     attr_reader :lparen_loc
@@ -11546,9 +11585,11 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (targets: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(targets, lparen_loc, rparen_loc, operator_loc, value, location)
-      @targets = targets
+    # def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location)
+      @lefts = lefts
+      @rest = rest
+      @rights = rights
       @lparen_loc = lparen_loc
       @rparen_loc = rparen_loc
       @operator_loc = operator_loc
@@ -11563,23 +11604,30 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [*targets, value]
+      [*lefts, rest, *rights, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [*targets, value]
+      compact = []
+      compact.concat(lefts)
+      compact << rest if rest
+      compact.concat(rights)
+      compact << value
+      compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*targets, *lparen_loc, *rparen_loc, operator_loc, value]
+      [*lefts, *rest, *rights, *lparen_loc, *rparen_loc, operator_loc, value]
     end
 
     # def copy: (**params) -> MultiWriteNode
     def copy(**params)
       MultiWriteNode.new(
-        params.fetch(:targets) { targets },
+        params.fetch(:lefts) { lefts },
+        params.fetch(:rest) { rest },
+        params.fetch(:rights) { rights },
         params.fetch(:lparen_loc) { lparen_loc },
         params.fetch(:rparen_loc) { rparen_loc },
         params.fetch(:operator_loc) { operator_loc },
@@ -11593,7 +11641,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { targets: targets, lparen_loc: lparen_loc, rparen_loc: rparen_loc, operator_loc: operator_loc, value: value, location: location }
+      { lefts: lefts, rest: rest, rights: rights, lparen_loc: lparen_loc, rparen_loc: rparen_loc, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def lparen: () -> String?
@@ -11611,9 +11659,17 @@ module Prism
       operator_loc.slice
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── targets: #{inspector.list("#{inspector.prefix}│   ", targets)}"
+      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"
@@ -11713,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?
@@ -11799,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
@@ -11899,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"
@@ -11985,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"
@@ -12020,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)
@@ -12091,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"
@@ -12195,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"
@@ -12323,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)}"
@@ -12406,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
 
@@ -12455,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?
@@ -12578,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"
@@ -12678,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"
@@ -12797,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?
@@ -12922,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?
@@ -13017,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"
@@ -13135,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?
@@ -13234,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"
@@ -13315,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
@@ -13474,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"
@@ -13514,55 +13687,50 @@ module Prism
     end
   end
 
-  # Represents a destructured required parameter node.
+  # Represents a required keyword parameter to a method, block, or lambda definition.
   #
-  #     def foo((bar, baz))
-  #             ^^^^^^^^^^
+  #     def a(b: )
+  #           ^^
   #     end
-  class RequiredDestructuredParameterNode < Node
-    # attr_reader parameters: Array[Node]
-    attr_reader :parameters
-
-    # attr_reader opening_loc: Location
-    attr_reader :opening_loc
+  class RequiredKeywordParameterNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
 
-    # attr_reader closing_loc: Location
-    attr_reader :closing_loc
+    # attr_reader name_loc: Location
+    attr_reader :name_loc
 
-    # def initialize: (parameters: Array[Node], opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def initialize(parameters, opening_loc, closing_loc, location)
-      @parameters = parameters
-      @opening_loc = opening_loc
-      @closing_loc = closing_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_destructured_parameter_node(self)
+      visitor.visit_required_keyword_parameter_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [*parameters]
+      []
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [*parameters]
+      []
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*parameters, opening_loc, closing_loc]
+      [name_loc]
     end
 
-    # def copy: (**params) -> RequiredDestructuredParameterNode
+    # def copy: (**params) -> RequiredKeywordParameterNode
     def copy(**params)
-      RequiredDestructuredParameterNode.new(
-        params.fetch(:parameters) { parameters },
-        params.fetch(:opening_loc) { opening_loc },
-        params.fetch(:closing_loc) { closing_loc },
+      RequiredKeywordParameterNode.new(
+        params.fetch(:name) { name },
+        params.fetch(:name_loc) { name_loc },
         params.fetch(:location) { location },
       )
     end
@@ -13572,24 +13740,14 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { parameters: parameters, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
-    end
-
-    # def opening: () -> String
-    def opening
-      opening_loc.slice
-    end
-
-    # def closing: () -> String
-    def closing
-      closing_loc.slice
+      { name: name, name_loc: name_loc, location: location }
     end
 
+    # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── parameters: #{inspector.list("#{inspector.prefix}│   ", parameters)}"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
+      inspector << "├── name: #{name.inspect}\n"
+      inspector << "└── name_loc: #{inspector.location(name_loc)}\n"
       inspector.to_str
     end
 
@@ -13608,7 +13766,7 @@ module Prism
     #
     # def type: () -> Symbol
     def type
-      :required_destructured_parameter_node
+      :required_keyword_parameter_node
     end
 
     # Similar to #type, this method returns a symbol that you can use for
@@ -13618,7 +13776,7 @@ module Prism
     #
     # def self.type: () -> Symbol
     def self.type
-      :required_destructured_parameter_node
+      :required_keyword_parameter_node
     end
   end
 
@@ -13673,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"
@@ -13710,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
@@ -13735,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
 
@@ -13777,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"
@@ -13820,8 +13980,8 @@ module Prism
   #
   #     begin
   #     rescue Foo, *splat, Bar => ex
-  #     ^^^^^^
   #       foo
+  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   #     end
   #
   # `Foo, *splat, Bar` are in the `exceptions` field.
@@ -13912,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"
@@ -14033,9 +14194,14 @@ 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"
+      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
@@ -14115,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
@@ -14211,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"
@@ -14297,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
@@ -14424,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"
@@ -14515,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
@@ -14599,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"
@@ -14679,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
@@ -14775,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"
@@ -14866,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)}"
@@ -14956,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"
@@ -15091,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
@@ -15222,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"
@@ -15354,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"
@@ -15437,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
@@ -15531,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)}"
@@ -15605,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
 
@@ -15658,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"
@@ -15746,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
 
@@ -15803,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"
@@ -15919,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"
@@ -15999,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
 
@@ -16056,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"
@@ -16182,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"
@@ -16302,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"
@@ -16345,6 +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
@@ -16353,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
@@ -16367,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
@@ -16403,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