prism 0.17.1 → 0.19.0

data/lib/prism/node.rb

@@ -38,6 +38,11 @@ module Prism
       end
       q.current_group.break
     end
+
+    # Convert this node into a graphviz dot graph string.
+    def to_dot
+      DotVisitor.new.tap { |visitor| accept(visitor) }.to_dot
+    end
   end
 
   # Represents the use of the `alias` keyword to alias a global variable.
@@ -465,16 +470,16 @@ module Prism
   #     return foo, bar, baz
   #            ^^^^^^^^^^^^^
   class ArgumentsNode < Node
-    # attr_reader arguments: Array[Node]
-    attr_reader :arguments
-
     # 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
+    # attr_reader arguments: Array[Node]
+    attr_reader :arguments
+
+    # def initialize: (flags: Integer, arguments: Array[Node], location: Location) -> void
+    def initialize(flags, arguments, location)
       @flags = flags
+      @arguments = arguments
       @location = location
     end
 
@@ -501,8 +506,8 @@ module Prism
     # def copy: (**params) -> ArgumentsNode
     def copy(**params)
       ArgumentsNode.new(
-        params.fetch(:arguments) { arguments },
         params.fetch(:flags) { flags },
+        params.fetch(:arguments) { arguments },
         params.fetch(:location) { location },
       )
     end
@@ -512,20 +517,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, flags: flags, location: location }
+      { flags: flags, arguments: arguments, location: location }
     end
 
-    # def keyword_splat?: () -> bool
-    def keyword_splat?
-      flags.anybits?(ArgumentsNodeFlags::KEYWORD_SPLAT)
+    # def contains_keyword_splat?: () -> bool
+    def contains_keyword_splat?
+      flags.anybits?(ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT)
     end
 
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── arguments: #{inspector.list("#{inspector.prefix}│   ", arguments)}"
-      flags = [("keyword_splat" if keyword_splat?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      flags = [("contains_keyword_splat" if contains_keyword_splat?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "└── arguments: #{inspector.list("#{inspector.prefix}    ", arguments)}"
       inspector.to_str
     end
 
@@ -564,6 +569,9 @@ module Prism
   #     [1, 2, 3]
   #     ^^^^^^^^^
   class ArrayNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader elements: Array[Node]
     attr_reader :elements
 
@@ -573,8 +581,9 @@ module Prism
     # attr_reader closing_loc: Location?
     attr_reader :closing_loc
 
-    # def initialize: (elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
-    def initialize(elements, opening_loc, closing_loc, location)
+    # def initialize: (flags: Integer, elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    def initialize(flags, elements, opening_loc, closing_loc, location)
+      @flags = flags
       @elements = elements
       @opening_loc = opening_loc
       @closing_loc = closing_loc
@@ -604,6 +613,7 @@ module Prism
     # def copy: (**params) -> ArrayNode
     def copy(**params)
       ArrayNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:elements) { elements },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:closing_loc) { closing_loc },
@@ -616,7 +626,12 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { elements: elements, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
+      { flags: flags, elements: elements, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
+    end
+
+    # def contains_splat?: () -> bool
+    def contains_splat?
+      flags.anybits?(ArrayNodeFlags::CONTAINS_SPLAT)
     end
 
     # def opening: () -> String?
@@ -632,6 +647,8 @@ module Prism
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("contains_splat" if contains_splat?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── elements: #{inspector.list("#{inspector.prefix}│   ", elements)}"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
@@ -1477,7 +1494,10 @@ module Prism
     # attr_reader locals: Array[Symbol]
     attr_reader :locals
 
-    # attr_reader parameters: BlockParametersNode?
+    # attr_reader locals_body_index: Integer
+    attr_reader :locals_body_index
+
+    # attr_reader parameters: Node?
     attr_reader :parameters
 
     # attr_reader body: Node?
@@ -1489,9 +1509,10 @@ module Prism
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
 
-    # def initialize: (locals: Array[Symbol], parameters: BlockParametersNode?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def initialize(locals, parameters, body, opening_loc, closing_loc, location)
+    # def initialize: (locals: Array[Symbol], locals_body_index: Integer, parameters: Node?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def initialize(locals, locals_body_index, parameters, body, opening_loc, closing_loc, location)
       @locals = locals
+      @locals_body_index = locals_body_index
       @parameters = parameters
       @body = body
       @opening_loc = opening_loc
@@ -1526,6 +1547,7 @@ module Prism
     def copy(**params)
       BlockNode.new(
         params.fetch(:locals) { locals },
+        params.fetch(:locals_body_index) { locals_body_index },
         params.fetch(:parameters) { parameters },
         params.fetch(:body) { body },
         params.fetch(:opening_loc) { opening_loc },
@@ -1539,7 +1561,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { locals: locals, parameters: parameters, body: body, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
+      { locals: locals, locals_body_index: locals_body_index, parameters: parameters, body: body, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
     end
 
     # def opening: () -> String
@@ -1556,6 +1578,7 @@ module Prism
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── locals: #{locals.inspect}\n"
+      inspector << "├── locals_body_index: #{locals_body_index.inspect}\n"
       if (parameters = self.parameters).nil?
         inspector << "├── parameters: ∅\n"
       else
@@ -1945,6 +1968,9 @@ module Prism
   #     foo.bar &&= value
   #     ^^^^^^^^^^^^^^^^^
   class CallAndWriteNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader receiver: Node?
     attr_reader :receiver
 
@@ -1954,9 +1980,6 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
     # attr_reader read_name: Symbol
     attr_reader :read_name
 
@@ -1969,12 +1992,12 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
+    # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location)
+      @flags = flags
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @flags = flags
       @read_name = read_name
       @write_name = write_name
       @operator_loc = operator_loc
@@ -2008,10 +2031,10 @@ module Prism
     # def copy: (**params) -> CallAndWriteNode
     def copy(**params)
       CallAndWriteNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:message_loc) { message_loc },
-        params.fetch(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
         params.fetch(:operator_loc) { operator_loc },
@@ -2025,17 +2048,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
-    end
-
-    # def call_operator: () -> String?
-    def call_operator
-      call_operator_loc&.slice
-    end
-
-    # def message: () -> String?
-    def message
-      message_loc&.slice
+      { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def safe_navigation?: () -> bool
@@ -2048,6 +2061,21 @@ module Prism
       flags.anybits?(CallNodeFlags::VARIABLE_CALL)
     end
 
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def message: () -> String?
+    def message
+      message_loc&.slice
+    end
+
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -2056,6 +2084,8 @@ module Prism
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       if (receiver = self.receiver).nil?
         inspector << "├── receiver: ∅\n"
       else
@@ -2064,8 +2094,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
       inspector << "├── write_name: #{write_name.inspect}\n"
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
@@ -2123,12 +2151,18 @@ module Prism
   #     foo&.bar
   #     ^^^^^^^^
   class CallNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader receiver: Node?
     attr_reader :receiver
 
     # attr_reader call_operator_loc: Location?
     attr_reader :call_operator_loc
 
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
@@ -2144,23 +2178,17 @@ module Prism
     # attr_reader block: Node?
     attr_reader :block
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # attr_reader name: Symbol
-    attr_reader :name
-
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, flags: Integer, name: Symbol, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location)
+    # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, location: Location) -> void
+    def initialize(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location)
+      @flags = flags
       @receiver = receiver
       @call_operator_loc = call_operator_loc
+      @name = name
       @message_loc = message_loc
       @opening_loc = opening_loc
       @arguments = arguments
       @closing_loc = closing_loc
       @block = block
-      @flags = flags
-      @name = name
       @location = location
     end
 
@@ -2191,15 +2219,15 @@ module Prism
     # def copy: (**params) -> CallNode
     def copy(**params)
       CallNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
+        params.fetch(:name) { name },
         params.fetch(:message_loc) { message_loc },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:arguments) { arguments },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:block) { block },
-        params.fetch(:flags) { flags },
-        params.fetch(:name) { name },
         params.fetch(:location) { location },
       )
     end
@@ -2209,7 +2237,22 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, name: name, location: location }
+      { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, location: location }
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
     end
 
     # def call_operator: () -> String?
@@ -2232,19 +2275,11 @@ module Prism
       closing_loc&.slice
     end
 
-    # def safe_navigation?: () -> bool
-    def safe_navigation?
-      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
-    end
-
-    # def variable_call?: () -> bool
-    def variable_call?
-      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
-    end
-
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       if (receiver = self.receiver).nil?
         inspector << "├── receiver: ∅\n"
       else
@@ -2252,6 +2287,7 @@ module Prism
         inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── name: #{name.inspect}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       if (arguments = self.arguments).nil?
@@ -2262,14 +2298,11 @@ module Prism
       end
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       if (block = self.block).nil?
-        inspector << "├── block: ∅\n"
+        inspector << "└── block: ∅\n"
       else
-        inspector << "├── block:\n"
-        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+        inspector << "└── block:\n"
+        inspector << block.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
       end
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "└── name: #{name.inspect}\n"
       inspector.to_str
     end
 
@@ -2307,6 +2340,9 @@ module Prism
   #     foo.bar += baz
   #     ^^^^^^^^^^^^^^
   class CallOperatorWriteNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader receiver: Node?
     attr_reader :receiver
 
@@ -2316,9 +2352,6 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
     # attr_reader read_name: Symbol
     attr_reader :read_name
 
@@ -2334,12 +2367,12 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location)
+    # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location)
+      @flags = flags
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @flags = flags
       @read_name = read_name
       @write_name = write_name
       @operator = operator
@@ -2374,10 +2407,10 @@ module Prism
     # def copy: (**params) -> CallOperatorWriteNode
     def copy(**params)
       CallOperatorWriteNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:message_loc) { message_loc },
-        params.fetch(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
         params.fetch(:operator) { operator },
@@ -2392,17 +2425,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
-    end
-
-    # def call_operator: () -> String?
-    def call_operator
-      call_operator_loc&.slice
-    end
-
-    # def message: () -> String?
-    def message
-      message_loc&.slice
+      { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def safe_navigation?: () -> bool
@@ -2415,9 +2438,26 @@ module Prism
       flags.anybits?(CallNodeFlags::VARIABLE_CALL)
     end
 
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def message: () -> String?
+    def message
+      message_loc&.slice
+    end
+
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       if (receiver = self.receiver).nil?
         inspector << "├── receiver: ∅\n"
       else
@@ -2426,8 +2466,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
       inspector << "├── write_name: #{write_name.inspect}\n"
       inspector << "├── operator: #{operator.inspect}\n"
@@ -2471,6 +2509,9 @@ module Prism
   #     foo.bar ||= value
   #     ^^^^^^^^^^^^^^^^^
   class CallOrWriteNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader receiver: Node?
     attr_reader :receiver
 
@@ -2480,9 +2521,6 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
     # attr_reader read_name: Symbol
     attr_reader :read_name
 
@@ -2495,12 +2533,12 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
+    # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location)
+      @flags = flags
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @flags = flags
       @read_name = read_name
       @write_name = write_name
       @operator_loc = operator_loc
@@ -2534,10 +2572,10 @@ module Prism
     # def copy: (**params) -> CallOrWriteNode
     def copy(**params)
       CallOrWriteNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:message_loc) { message_loc },
-        params.fetch(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
         params.fetch(:operator_loc) { operator_loc },
@@ -2551,17 +2589,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
-    end
-
-    # def call_operator: () -> String?
-    def call_operator
-      call_operator_loc&.slice
-    end
-
-    # def message: () -> String?
-    def message
-      message_loc&.slice
+      { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def safe_navigation?: () -> bool
@@ -2574,6 +2602,21 @@ module Prism
       flags.anybits?(CallNodeFlags::VARIABLE_CALL)
     end
 
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def message: () -> String?
+    def message
+      message_loc&.slice
+    end
+
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -2582,6 +2625,8 @@ module Prism
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       if (receiver = self.receiver).nil?
         inspector << "├── receiver: ∅\n"
       else
@@ -2590,8 +2635,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
       inspector << "├── write_name: #{write_name.inspect}\n"
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
@@ -2629,54 +2672,72 @@ module Prism
     end
   end
 
-  # Represents assigning to a local variable in pattern matching.
+  # Represents assigning to a method call.
   #
-  #     foo => [bar => baz]
-  #            ^^^^^^^^^^^^
-  class CapturePatternNode < Node
-    # attr_reader value: Node
-    attr_reader :value
+  #     foo.bar, = 1
+  #     ^^^^^^^
+  #
+  #     begin
+  #     rescue => foo.bar
+  #               ^^^^^^^
+  #     end
+  #
+  #     for foo.bar in baz do end
+  #         ^^^^^^^
+  class CallTargetNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
 
-    # attr_reader target: Node
-    attr_reader :target
+    # attr_reader receiver: Node
+    attr_reader :receiver
 
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
+    # attr_reader call_operator_loc: Location
+    attr_reader :call_operator_loc
 
-    # def initialize: (value: Node, target: Node, operator_loc: Location, location: Location) -> void
-    def initialize(value, target, operator_loc, location)
-      @value = value
-      @target = target
-      @operator_loc = operator_loc
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # attr_reader message_loc: Location
+    attr_reader :message_loc
+
+    # def initialize: (flags: Integer, receiver: Node, call_operator_loc: Location, name: Symbol, message_loc: Location, location: Location) -> void
+    def initialize(flags, receiver, call_operator_loc, name, message_loc, location)
+      @flags = flags
+      @receiver = receiver
+      @call_operator_loc = call_operator_loc
+      @name = name
+      @message_loc = message_loc
       @location = location
     end
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_capture_pattern_node(self)
+      visitor.visit_call_target_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value, target]
+      [receiver]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [value, target]
+      [receiver]
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [value, target, operator_loc]
+      [receiver, call_operator_loc, message_loc]
     end
 
-    # def copy: (**params) -> CapturePatternNode
+    # def copy: (**params) -> CallTargetNode
     def copy(**params)
-      CapturePatternNode.new(
-        params.fetch(:value) { value },
-        params.fetch(:target) { target },
-        params.fetch(:operator_loc) { operator_loc },
+      CallTargetNode.new(
+        params.fetch(:flags) { flags },
+        params.fetch(:receiver) { receiver },
+        params.fetch(:call_operator_loc) { call_operator_loc },
+        params.fetch(:name) { name },
+        params.fetch(:message_loc) { message_loc },
         params.fetch(:location) { location },
       )
     end
@@ -2686,22 +2747,44 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { value: value, target: target, operator_loc: operator_loc, location: location }
+      { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, location: location }
     end
 
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
+    end
+
+    # def call_operator: () -> String
+    def call_operator
+      call_operator_loc.slice
+    end
+
+    # def message: () -> String
+    def message
+      message_loc.slice
     end
 
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── value:\n"
-      inspector << inspector.child_node(value, "│   ")
-      inspector << "├── target:\n"
-      inspector << inspector.child_node(target, "│   ")
-      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "├── receiver:\n"
+      inspector << inspector.child_node(receiver, "│   ")
+      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── name: #{name.inspect}\n"
+      inspector << "└── message_loc: #{inspector.location(message_loc)}\n"
       inspector.to_str
     end
 
@@ -2720,7 +2803,7 @@ module Prism
     #
     # def type: () -> Symbol
     def type
-      :capture_pattern_node
+      :call_target_node
     end
 
     # Similar to #type, this method returns a symbol that you can use for
@@ -2730,11 +2813,252 @@ module Prism
     #
     # def self.type: () -> Symbol
     def self.type
-      :capture_pattern_node
+      :call_target_node
     end
   end
 
-  # Represents the use of a case statement.
+  # Represents assigning to a local variable in pattern matching.
+  #
+  #     foo => [bar => baz]
+  #            ^^^^^^^^^^^^
+  class CapturePatternNode < Node
+    # attr_reader value: Node
+    attr_reader :value
+
+    # attr_reader target: Node
+    attr_reader :target
+
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # def initialize: (value: Node, target: Node, operator_loc: Location, location: Location) -> void
+    def initialize(value, target, operator_loc, location)
+      @value = value
+      @target = target
+      @operator_loc = operator_loc
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_capture_pattern_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [value, target]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      [value, target]
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [value, target, operator_loc]
+    end
+
+    # def copy: (**params) -> CapturePatternNode
+    def copy(**params)
+      CapturePatternNode.new(
+        params.fetch(:value) { value },
+        params.fetch(:target) { target },
+        params.fetch(:operator_loc) { operator_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)
+      { value: value, target: target, operator_loc: operator_loc, location: location }
+    end
+
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
+    # def inspect(inspector: NodeInspector) -> String
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      inspector << "├── value:\n"
+      inspector << inspector.child_node(value, "│   ")
+      inspector << "├── target:\n"
+      inspector << inspector.child_node(target, "│   ")
+      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector.to_str
+    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
+      :capture_pattern_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
+      :capture_pattern_node
+    end
+  end
+
+  # Represents the use of a case statement for pattern matching.
+  #
+  #     case true
+  #     in false
+  #     end
+  #     ^^^^^^^^^
+  class CaseMatchNode < Node
+    # attr_reader predicate: Node?
+    attr_reader :predicate
+
+    # attr_reader conditions: Array[Node]
+    attr_reader :conditions
+
+    # attr_reader consequent: ElseNode?
+    attr_reader :consequent
+
+    # attr_reader case_keyword_loc: Location
+    attr_reader :case_keyword_loc
+
+    # attr_reader end_keyword_loc: Location
+    attr_reader :end_keyword_loc
+
+    # def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
+    def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location)
+      @predicate = predicate
+      @conditions = conditions
+      @consequent = consequent
+      @case_keyword_loc = case_keyword_loc
+      @end_keyword_loc = end_keyword_loc
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_case_match_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [predicate, *conditions, consequent]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      compact = []
+      compact << predicate if predicate
+      compact.concat(conditions)
+      compact << consequent if consequent
+      compact
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [*predicate, *conditions, *consequent, case_keyword_loc, end_keyword_loc]
+    end
+
+    # def copy: (**params) -> CaseMatchNode
+    def copy(**params)
+      CaseMatchNode.new(
+        params.fetch(:predicate) { predicate },
+        params.fetch(:conditions) { conditions },
+        params.fetch(:consequent) { consequent },
+        params.fetch(:case_keyword_loc) { case_keyword_loc },
+        params.fetch(:end_keyword_loc) { end_keyword_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)
+      { predicate: predicate, conditions: conditions, consequent: consequent, case_keyword_loc: case_keyword_loc, end_keyword_loc: end_keyword_loc, location: location }
+    end
+
+    # def case_keyword: () -> String
+    def case_keyword
+      case_keyword_loc.slice
+    end
+
+    # def end_keyword: () -> String
+    def end_keyword
+      end_keyword_loc.slice
+    end
+
+    # def inspect(inspector: NodeInspector) -> String
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      if (predicate = self.predicate).nil?
+        inspector << "├── predicate: ∅\n"
+      else
+        inspector << "├── predicate:\n"
+        inspector << predicate.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── conditions: #{inspector.list("#{inspector.prefix}│   ", conditions)}"
+      if (consequent = self.consequent).nil?
+        inspector << "├── consequent: ∅\n"
+      else
+        inspector << "├── consequent:\n"
+        inspector << consequent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── case_keyword_loc: #{inspector.location(case_keyword_loc)}\n"
+      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
+      inspector.to_str
+    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
+      :case_match_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
+      :case_match_node
+    end
+  end
+
+  # Represents the use of a case statement.
   #
   #     case true
   #     when false
@@ -4929,6 +5253,9 @@ module Prism
     # attr_reader locals: Array[Symbol]
     attr_reader :locals
 
+    # attr_reader locals_body_index: Integer
+    attr_reader :locals_body_index
+
     # attr_reader def_keyword_loc: Location
     attr_reader :def_keyword_loc
 
@@ -4947,14 +5274,15 @@ module Prism
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void
-    def initialize(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
+    # def initialize: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], locals_body_index: Integer, def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize(name, name_loc, receiver, parameters, body, locals, locals_body_index, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
       @name = name
       @name_loc = name_loc
       @receiver = receiver
       @parameters = parameters
       @body = body
       @locals = locals
+      @locals_body_index = locals_body_index
       @def_keyword_loc = def_keyword_loc
       @operator_loc = operator_loc
       @lparen_loc = lparen_loc
@@ -4997,6 +5325,7 @@ module Prism
         params.fetch(:parameters) { parameters },
         params.fetch(:body) { body },
         params.fetch(:locals) { locals },
+        params.fetch(:locals_body_index) { locals_body_index },
         params.fetch(:def_keyword_loc) { def_keyword_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:lparen_loc) { lparen_loc },
@@ -5012,7 +5341,7 @@ module Prism
 
     # 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, receiver: receiver, parameters: parameters, body: body, locals: locals, def_keyword_loc: def_keyword_loc, operator_loc: operator_loc, lparen_loc: lparen_loc, rparen_loc: rparen_loc, equal_loc: equal_loc, end_keyword_loc: end_keyword_loc, location: location }
+      { name: name, name_loc: name_loc, receiver: receiver, parameters: parameters, body: body, locals: locals, locals_body_index: locals_body_index, def_keyword_loc: def_keyword_loc, operator_loc: operator_loc, lparen_loc: lparen_loc, rparen_loc: rparen_loc, equal_loc: equal_loc, end_keyword_loc: end_keyword_loc, location: location }
     end
 
     # def def_keyword: () -> String
@@ -5069,6 +5398,7 @@ module Prism
         inspector << body.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
       inspector << "├── locals: #{locals.inspect}\n"
+      inspector << "├── locals_body_index: #{locals_body_index.inspect}\n"
       inspector << "├── def_keyword_loc: #{inspector.location(def_keyword_loc)}\n"
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
@@ -5903,6 +6233,9 @@ module Prism
   #     baz if foo .. bar
   #            ^^^^^^^^^^
   class FlipFlopNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader left: Node?
     attr_reader :left
 
@@ -5912,15 +6245,12 @@ module Prism
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void
-    def initialize(left, right, operator_loc, flags, location)
+    # def initialize: (flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location) -> void
+    def initialize(flags, left, right, operator_loc, location)
+      @flags = flags
       @left = left
       @right = right
       @operator_loc = operator_loc
-      @flags = flags
       @location = location
     end
 
@@ -5950,10 +6280,10 @@ module Prism
     # def copy: (**params) -> FlipFlopNode
     def copy(**params)
       FlipFlopNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:left) { left },
         params.fetch(:right) { right },
         params.fetch(:operator_loc) { operator_loc },
-        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -5963,12 +6293,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { left: left, right: right, operator_loc: operator_loc, flags: flags, location: location }
-    end
-
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+      { flags: flags, left: left, right: right, operator_loc: operator_loc, location: location }
     end
 
     # def exclude_end?: () -> bool
@@ -5976,10 +6301,17 @@ module Prism
       flags.anybits?(RangeFlags::EXCLUDE_END)
     end
 
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      if (left = self.left).nil?
+      flags = [("exclude_end" if exclude_end?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      if (left = self.left).nil?
         inspector << "├── left: ∅\n"
       else
         inspector << "├── left:\n"
@@ -5991,9 +6323,7 @@ module Prism
         inspector << "├── right:\n"
         inspector << right.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      flags = [("exclude_end" if exclude_end?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector.to_str
     end
 
@@ -7387,6 +7717,9 @@ module Prism
     # attr_reader predicate: Node
     attr_reader :predicate
 
+    # attr_reader then_keyword_loc: Location?
+    attr_reader :then_keyword_loc
+
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
@@ -7396,10 +7729,11 @@ module Prism
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
-    def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
+    # def initialize: (if_keyword_loc: Location?, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
       @if_keyword_loc = if_keyword_loc
       @predicate = predicate
+      @then_keyword_loc = then_keyword_loc
       @statements = statements
       @consequent = consequent
       @end_keyword_loc = end_keyword_loc
@@ -7431,7 +7765,7 @@ module Prism
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*if_keyword_loc, predicate, *statements, *consequent, *end_keyword_loc]
+      [*if_keyword_loc, predicate, *then_keyword_loc, *statements, *consequent, *end_keyword_loc]
     end
 
     # def copy: (**params) -> IfNode
@@ -7439,6 +7773,7 @@ module Prism
       IfNode.new(
         params.fetch(:if_keyword_loc) { if_keyword_loc },
         params.fetch(:predicate) { predicate },
+        params.fetch(:then_keyword_loc) { then_keyword_loc },
         params.fetch(:statements) { statements },
         params.fetch(:consequent) { consequent },
         params.fetch(:end_keyword_loc) { end_keyword_loc },
@@ -7451,7 +7786,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { if_keyword_loc: if_keyword_loc, predicate: predicate, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
+      { if_keyword_loc: if_keyword_loc, predicate: predicate, then_keyword_loc: then_keyword_loc, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
     end
 
     # def if_keyword: () -> String?
@@ -7459,6 +7794,11 @@ module Prism
       if_keyword_loc&.slice
     end
 
+    # def then_keyword: () -> String?
+    def then_keyword
+      then_keyword_loc&.slice
+    end
+
     # def end_keyword: () -> String?
     def end_keyword
       end_keyword_loc&.slice
@@ -7470,6 +7810,7 @@ module Prism
       inspector << "├── if_keyword_loc: #{inspector.location(if_keyword_loc)}\n"
       inspector << "├── predicate:\n"
       inspector << inspector.child_node(predicate, "│   ")
+      inspector << "├── then_keyword_loc: #{inspector.location(then_keyword_loc)}\n"
       if (statements = self.statements).nil?
         inspector << "├── statements: ∅\n"
       else
@@ -7693,6 +8034,95 @@ module Prism
     end
   end
 
+  # Represents using a trailing comma to indicate an implicit rest parameter.
+  #
+  #     foo { |bar,| }
+  #               ^
+  #
+  #     foo in [bar,]
+  #                ^
+  #
+  #     for foo, in bar do end
+  #            ^
+  #
+  #     foo, = bar
+  #        ^
+  class ImplicitRestNode < Node
+    # def initialize: (location: Location) -> void
+    def initialize(location)
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_implicit_rest_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
+      []
+    end
+
+    # def copy: (**params) -> ImplicitRestNode
+    def copy(**params)
+      ImplicitRestNode.new(
+        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)
+      { location: location }
+    end
+
+    # def inspect(inspector: NodeInspector) -> String
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      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
+      :implicit_rest_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
+      :implicit_rest_node
+    end
+  end
+
   # Represents the use of the `in` keyword in a case statement.
   #
   #     case a; in b then c end
@@ -7821,6 +8251,9 @@ module Prism
   #     foo.bar[baz] &&= value
   #     ^^^^^^^^^^^^^^^^^^^^^^
   class IndexAndWriteNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader receiver: Node?
     attr_reader :receiver
 
@@ -7839,24 +8272,21 @@ module Prism
     # attr_reader block: Node?
     attr_reader :block
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
+    # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location)
+      @flags = flags
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @opening_loc = opening_loc
       @arguments = arguments
       @closing_loc = closing_loc
       @block = block
-      @flags = flags
       @operator_loc = operator_loc
       @value = value
       @location = location
@@ -7890,13 +8320,13 @@ module Prism
     # def copy: (**params) -> IndexAndWriteNode
     def copy(**params)
       IndexAndWriteNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:arguments) { arguments },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:block) { block },
-        params.fetch(:flags) { flags },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
         params.fetch(:location) { location },
@@ -7908,7 +8338,22 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator_loc: operator_loc, value: value, location: location }
+      { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
     end
 
     # def call_operator: () -> String?
@@ -7926,16 +8371,6 @@ module Prism
       closing_loc.slice
     end
 
-    # def safe_navigation?: () -> bool
-    def safe_navigation?
-      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
-    end
-
-    # def variable_call?: () -> bool
-    def variable_call?
-      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
-    end
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -7944,6 +8379,8 @@ module Prism
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       if (receiver = self.receiver).nil?
         inspector << "├── receiver: ∅\n"
       else
@@ -7965,8 +8402,6 @@ module Prism
         inspector << "├── block:\n"
         inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector << "└── value:\n"
       inspector << inspector.child_node(value, "    ")
@@ -8007,6 +8442,9 @@ module Prism
   #     foo.bar[baz] += value
   #     ^^^^^^^^^^^^^^^^^^^^^
   class IndexOperatorWriteNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader receiver: Node?
     attr_reader :receiver
 
@@ -8025,9 +8463,6 @@ module Prism
     # attr_reader block: Node?
     attr_reader :block
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
     # attr_reader operator: Symbol
     attr_reader :operator
 
@@ -8037,15 +8472,15 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location)
+    # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location)
+      @flags = flags
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @opening_loc = opening_loc
       @arguments = arguments
       @closing_loc = closing_loc
       @block = block
-      @flags = flags
       @operator = operator
       @operator_loc = operator_loc
       @value = value
@@ -8080,13 +8515,13 @@ module Prism
     # def copy: (**params) -> IndexOperatorWriteNode
     def copy(**params)
       IndexOperatorWriteNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:arguments) { arguments },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:block) { block },
-        params.fetch(:flags) { flags },
         params.fetch(:operator) { operator },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
@@ -8099,7 +8534,22 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator: operator, operator_loc: operator_loc, value: value, location: location }
+      { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator: operator, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
     end
 
     # def call_operator: () -> String?
@@ -8117,19 +8567,11 @@ module Prism
       closing_loc.slice
     end
 
-    # def safe_navigation?: () -> bool
-    def safe_navigation?
-      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
-    end
-
-    # def variable_call?: () -> bool
-    def variable_call?
-      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
-    end
-
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       if (receiver = self.receiver).nil?
         inspector << "├── receiver: ∅\n"
       else
@@ -8151,8 +8593,6 @@ module Prism
         inspector << "├── block:\n"
         inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── operator: #{operator.inspect}\n"
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector << "└── value:\n"
@@ -8194,6 +8634,9 @@ module Prism
   #     foo.bar[baz] ||= value
   #     ^^^^^^^^^^^^^^^^^^^^^^
   class IndexOrWriteNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader receiver: Node?
     attr_reader :receiver
 
@@ -8212,24 +8655,21 @@ module Prism
     # attr_reader block: Node?
     attr_reader :block
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
+    # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location)
+      @flags = flags
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @opening_loc = opening_loc
       @arguments = arguments
       @closing_loc = closing_loc
       @block = block
-      @flags = flags
       @operator_loc = operator_loc
       @value = value
       @location = location
@@ -8263,13 +8703,13 @@ module Prism
     # def copy: (**params) -> IndexOrWriteNode
     def copy(**params)
       IndexOrWriteNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:arguments) { arguments },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:block) { block },
-        params.fetch(:flags) { flags },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
         params.fetch(:location) { location },
@@ -8281,7 +8721,22 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator_loc: operator_loc, value: value, location: location }
+      { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
     end
 
     # def call_operator: () -> String?
@@ -8299,16 +8754,6 @@ module Prism
       closing_loc.slice
     end
 
-    # def safe_navigation?: () -> bool
-    def safe_navigation?
-      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
-    end
-
-    # def variable_call?: () -> bool
-    def variable_call?
-      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
-    end
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -8317,6 +8762,8 @@ module Prism
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       if (receiver = self.receiver).nil?
         inspector << "├── receiver: ∅\n"
       else
@@ -8333,16 +8780,179 @@ module Prism
       end
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       if (block = self.block).nil?
-        inspector << "├── block: ∅\n"
+        inspector << "├── block: ∅\n"
+      else
+        inspector << "├── block:\n"
+        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── value:\n"
+      inspector << inspector.child_node(value, "    ")
+      inspector.to_str
+    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
+      :index_or_write_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
+      :index_or_write_node
+    end
+  end
+
+  # Represents assigning to an index.
+  #
+  #     foo[bar], = 1
+  #     ^^^^^^^^
+  #
+  #     begin
+  #     rescue => foo[bar]
+  #               ^^^^^^^^
+  #     end
+  #
+  #     for foo[bar] in baz do end
+  #         ^^^^^^^^
+  class IndexTargetNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
+    # attr_reader receiver: Node
+    attr_reader :receiver
+
+    # attr_reader opening_loc: Location
+    attr_reader :opening_loc
+
+    # attr_reader arguments: ArgumentsNode?
+    attr_reader :arguments
+
+    # attr_reader closing_loc: Location
+    attr_reader :closing_loc
+
+    # attr_reader block: Node?
+    attr_reader :block
+
+    # def initialize: (flags: Integer, receiver: Node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, location: Location) -> void
+    def initialize(flags, receiver, opening_loc, arguments, closing_loc, block, location)
+      @flags = flags
+      @receiver = receiver
+      @opening_loc = opening_loc
+      @arguments = arguments
+      @closing_loc = closing_loc
+      @block = block
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_index_target_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [receiver, arguments, block]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      compact = []
+      compact << receiver
+      compact << arguments if arguments
+      compact << block if block
+      compact
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [receiver, opening_loc, *arguments, closing_loc, *block]
+    end
+
+    # def copy: (**params) -> IndexTargetNode
+    def copy(**params)
+      IndexTargetNode.new(
+        params.fetch(:flags) { flags },
+        params.fetch(:receiver) { receiver },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:arguments) { arguments },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:block) { block },
+        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)
+      { flags: flags, receiver: receiver, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, location: location }
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def attribute_write?: () -> bool
+    def attribute_write?
+      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
+    # def inspect(inspector: NodeInspector) -> String
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "├── receiver:\n"
+      inspector << inspector.child_node(receiver, "│   ")
+      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
+      if (arguments = self.arguments).nil?
+        inspector << "├── arguments: ∅\n"
+      else
+        inspector << "├── arguments:\n"
+        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
+      if (block = self.block).nil?
+        inspector << "└── block: ∅\n"
       else
-        inspector << "├── block:\n"
-        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+        inspector << "└── block:\n"
+        inspector << block.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
       end
-      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
-      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
       inspector.to_str
     end
 
@@ -8361,7 +8971,7 @@ module Prism
     #
     # def type: () -> Symbol
     def type
-      :index_or_write_node
+      :index_target_node
     end
 
     # Similar to #type, this method returns a symbol that you can use for
@@ -8371,7 +8981,7 @@ module Prism
     #
     # def self.type: () -> Symbol
     def self.type
-      :index_or_write_node
+      :index_target_node
     end
   end
 
@@ -9043,16 +9653,16 @@ module Prism
       flags.anybits?(IntegerBaseFlags::BINARY)
     end
 
-    # def octal?: () -> bool
-    def octal?
-      flags.anybits?(IntegerBaseFlags::OCTAL)
-    end
-
     # def decimal?: () -> bool
     def decimal?
       flags.anybits?(IntegerBaseFlags::DECIMAL)
     end
 
+    # def octal?: () -> bool
+    def octal?
+      flags.anybits?(IntegerBaseFlags::OCTAL)
+    end
+
     # def hexadecimal?: () -> bool
     def hexadecimal?
       flags.anybits?(IntegerBaseFlags::HEXADECIMAL)
@@ -9061,7 +9671,7 @@ module Prism
     # 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
+      flags = [("binary" if binary?), ("decimal" if decimal?), ("octal" if octal?), ("hexadecimal" if hexadecimal?)].compact
       inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
@@ -9102,6 +9712,9 @@ module Prism
   #     if /foo #{bar} baz/ then end
   #        ^^^^^^^^^^^^^^^^
   class InterpolatedMatchLastLineNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
 
@@ -9111,15 +9724,12 @@ module Prism
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, flags: Integer, location: Location) -> void
-    def initialize(opening_loc, parts, closing_loc, flags, location)
+    # def initialize: (flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
+    def initialize(flags, opening_loc, parts, closing_loc, location)
+      @flags = flags
       @opening_loc = opening_loc
       @parts = parts
       @closing_loc = closing_loc
-      @flags = flags
       @location = location
     end
 
@@ -9151,10 +9761,10 @@ module Prism
     # def copy: (**params) -> InterpolatedMatchLastLineNode
     def copy(**params)
       InterpolatedMatchLastLineNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:parts) { parts },
         params.fetch(:closing_loc) { closing_loc },
-        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -9164,17 +9774,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, flags: flags, location: location }
-    end
-
-    # def opening: () -> String
-    def opening
-      opening_loc.slice
-    end
-
-    # def closing: () -> String
-    def closing
-      closing_loc.slice
+      { flags: flags, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, location: location }
     end
 
     # def ignore_case?: () -> bool
@@ -9217,14 +9817,39 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
+    # def forced_utf8_encoding?: () -> bool
+    def forced_utf8_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_UTF8_ENCODING)
+    end
+
+    # def forced_binary_encoding?: () -> bool
+    def forced_binary_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_BINARY_ENCODING)
+    end
+
+    # def forced_us_ascii_encoding?: () -> bool
+    def forced_us_ascii_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_US_ASCII_ENCODING)
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
       inspector.to_str
     end
 
@@ -9262,6 +9887,9 @@ module Prism
   #     /foo #{bar} baz/
   #     ^^^^^^^^^^^^^^^^
   class InterpolatedRegularExpressionNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
 
@@ -9271,15 +9899,12 @@ module Prism
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, flags: Integer, location: Location) -> void
-    def initialize(opening_loc, parts, closing_loc, flags, location)
+    # def initialize: (flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
+    def initialize(flags, opening_loc, parts, closing_loc, location)
+      @flags = flags
       @opening_loc = opening_loc
       @parts = parts
       @closing_loc = closing_loc
-      @flags = flags
       @location = location
     end
 
@@ -9311,10 +9936,10 @@ module Prism
     # def copy: (**params) -> InterpolatedRegularExpressionNode
     def copy(**params)
       InterpolatedRegularExpressionNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:parts) { parts },
         params.fetch(:closing_loc) { closing_loc },
-        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -9324,17 +9949,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, flags: flags, location: location }
-    end
-
-    # def opening: () -> String
-    def opening
-      opening_loc.slice
-    end
-
-    # def closing: () -> String
-    def closing
-      closing_loc.slice
+      { flags: flags, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, location: location }
     end
 
     # def ignore_case?: () -> bool
@@ -9377,14 +9992,39 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
+    # def forced_utf8_encoding?: () -> bool
+    def forced_utf8_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_UTF8_ENCODING)
+    end
+
+    # def forced_binary_encoding?: () -> bool
+    def forced_binary_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_BINARY_ENCODING)
+    end
+
+    # def forced_us_ascii_encoding?: () -> bool
+    def forced_us_ascii_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_US_ASCII_ENCODING)
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
       inspector.to_str
     end
 
@@ -9761,11 +10401,15 @@ module Prism
   #     foo(a: b)
   #         ^^^^
   class KeywordHashNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader elements: Array[Node]
     attr_reader :elements
 
-    # def initialize: (elements: Array[Node], location: Location) -> void
-    def initialize(elements, location)
+    # def initialize: (flags: Integer, elements: Array[Node], location: Location) -> void
+    def initialize(flags, elements, location)
+      @flags = flags
       @elements = elements
       @location = location
     end
@@ -9793,6 +10437,7 @@ module Prism
     # def copy: (**params) -> KeywordHashNode
     def copy(**params)
       KeywordHashNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:elements) { elements },
         params.fetch(:location) { location },
       )
@@ -9803,12 +10448,19 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { elements: elements, location: location }
+      { flags: flags, elements: elements, location: location }
+    end
+
+    # def static_keys?: () -> bool
+    def static_keys?
+      flags.anybits?(KeywordHashNodeFlags::STATIC_KEYS)
     end
 
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("static_keys" if static_keys?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "└── elements: #{inspector.list("#{inspector.prefix}    ", elements)}"
       inspector.to_str
     end
@@ -9958,6 +10610,9 @@ module Prism
     # attr_reader locals: Array[Symbol]
     attr_reader :locals
 
+    # attr_reader locals_body_index: Integer
+    attr_reader :locals_body_index
+
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
@@ -9967,15 +10622,16 @@ module Prism
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
 
-    # attr_reader parameters: BlockParametersNode?
+    # attr_reader parameters: Node?
     attr_reader :parameters
 
     # attr_reader body: Node?
     attr_reader :body
 
-    # def initialize: (locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode?, body: Node?, location: Location) -> void
-    def initialize(locals, operator_loc, opening_loc, closing_loc, parameters, body, location)
+    # def initialize: (locals: Array[Symbol], locals_body_index: Integer, operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Node?, body: Node?, location: Location) -> void
+    def initialize(locals, locals_body_index, operator_loc, opening_loc, closing_loc, parameters, body, location)
       @locals = locals
+      @locals_body_index = locals_body_index
       @operator_loc = operator_loc
       @opening_loc = opening_loc
       @closing_loc = closing_loc
@@ -10011,6 +10667,7 @@ module Prism
     def copy(**params)
       LambdaNode.new(
         params.fetch(:locals) { locals },
+        params.fetch(:locals_body_index) { locals_body_index },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:closing_loc) { closing_loc },
@@ -10025,7 +10682,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { locals: locals, operator_loc: operator_loc, opening_loc: opening_loc, closing_loc: closing_loc, parameters: parameters, body: body, location: location }
+      { locals: locals, locals_body_index: locals_body_index, operator_loc: operator_loc, opening_loc: opening_loc, closing_loc: closing_loc, parameters: parameters, body: body, location: location }
     end
 
     # def operator: () -> String
@@ -10047,6 +10704,7 @@ module Prism
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── locals: #{locals.inspect}\n"
+      inspector << "├── locals_body_index: #{locals_body_index.inspect}\n"
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
@@ -10752,6 +11410,9 @@ module Prism
   #     if /foo/i then end
   #        ^^^^^^
   class MatchLastLineNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
 
@@ -10764,16 +11425,13 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> void
-    def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location)
+    # def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
+    def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location)
+      @flags = flags
       @opening_loc = opening_loc
       @content_loc = content_loc
       @closing_loc = closing_loc
       @unescaped = unescaped
-      @flags = flags
       @location = location
     end
 
@@ -10800,11 +11458,11 @@ module Prism
     # def copy: (**params) -> MatchLastLineNode
     def copy(**params)
       MatchLastLineNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:content_loc) { content_loc },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:unescaped) { unescaped },
-        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -10814,22 +11472,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, flags: flags, location: location }
-    end
-
-    # def opening: () -> String
-    def opening
-      opening_loc.slice
-    end
-
-    # def content: () -> String
-    def content
-      content_loc.slice
-    end
-
-    # def closing: () -> String
-    def closing
-      closing_loc.slice
+      { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
     end
 
     # def ignore_case?: () -> bool
@@ -10872,15 +11515,45 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
+    # def forced_utf8_encoding?: () -> bool
+    def forced_utf8_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_UTF8_ENCODING)
+    end
+
+    # def forced_binary_encoding?: () -> bool
+    def forced_binary_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_BINARY_ENCODING)
+    end
+
+    # def forced_us_ascii_encoding?: () -> bool
+    def forced_us_ascii_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_US_ASCII_ENCODING)
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def content: () -> String
+    def content
+      content_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "├── unescaped: #{unescaped.inspect}\n"
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "└── unescaped: #{unescaped.inspect}\n"
       inspector.to_str
     end
 
@@ -11132,13 +11805,13 @@ module Prism
     # attr_reader call: CallNode
     attr_reader :call
 
-    # attr_reader locals: Array[Symbol]
-    attr_reader :locals
+    # attr_reader targets: Array[Node]
+    attr_reader :targets
 
-    # def initialize: (call: CallNode, locals: Array[Symbol], location: Location) -> void
-    def initialize(call, locals, location)
+    # def initialize: (call: CallNode, targets: Array[Node], location: Location) -> void
+    def initialize(call, targets, location)
       @call = call
-      @locals = locals
+      @targets = targets
       @location = location
     end
 
@@ -11149,24 +11822,24 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [call]
+      [call, *targets]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [call]
+      [call, *targets]
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [call]
+      [call, *targets]
     end
 
     # def copy: (**params) -> MatchWriteNode
     def copy(**params)
       MatchWriteNode.new(
         params.fetch(:call) { call },
-        params.fetch(:locals) { locals },
+        params.fetch(:targets) { targets },
         params.fetch(:location) { location },
       )
     end
@@ -11176,7 +11849,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { call: call, locals: locals, location: location }
+      { call: call, targets: targets, location: location }
     end
 
     # def inspect(inspector: NodeInspector) -> String
@@ -11184,7 +11857,7 @@ module Prism
       inspector << inspector.header(self)
       inspector << "├── call:\n"
       inspector << inspector.child_node(call, "│   ")
-      inspector << "└── locals: #{locals.inspect}\n"
+      inspector << "└── targets: #{inspector.list("#{inspector.prefix}    ", targets)}"
       inspector.to_str
     end
 
@@ -11994,6 +12667,93 @@ module Prism
     end
   end
 
+  # Represents an implicit set of parameters through the use of numbered
+  # parameters within a block or lambda.
+  #
+  #     -> { _1 + _2 }
+  #     ^^^^^^^^^^^^^^
+  class NumberedParametersNode < Node
+    # attr_reader maximum: Integer
+    attr_reader :maximum
+
+    # def initialize: (maximum: Integer, location: Location) -> void
+    def initialize(maximum, location)
+      @maximum = maximum
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_numbered_parameters_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
+      []
+    end
+
+    # def copy: (**params) -> NumberedParametersNode
+    def copy(**params)
+      NumberedParametersNode.new(
+        params.fetch(:maximum) { maximum },
+        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)
+      { maximum: maximum, location: location }
+    end
+
+    # def inspect(inspector: NodeInspector) -> String
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      inspector << "└── maximum: #{maximum.inspect}\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
+      :numbered_parameters_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
+      :numbered_parameters_node
+    end
+  end
+
   # Represents reading a numbered reference to a capture in the previous match.
   #
   #     $1
@@ -12408,7 +13168,7 @@ module Prism
     # attr_reader optionals: Array[Node]
     attr_reader :optionals
 
-    # attr_reader rest: RestParameterNode?
+    # attr_reader rest: Node?
     attr_reader :rest
 
     # attr_reader posts: Array[Node]
@@ -12423,7 +13183,7 @@ module Prism
     # attr_reader block: BlockParameterNode?
     attr_reader :block
 
-    # def initialize: (requireds: Array[Node], optionals: Array[Node], rest: RestParameterNode?, posts: Array[Node], keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void
+    # def initialize: (requireds: Array[Node], optionals: Array[Node], rest: Node?, posts: Array[Node], keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void
     def initialize(requireds, optionals, rest, posts, keywords, keyword_rest, block, location)
       @requireds = requireds
       @optionals = optionals
@@ -13231,6 +13991,9 @@ module Prism
   #     c if a =~ /left/ ... b =~ /right/
   #          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   class RangeNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader left: Node?
     attr_reader :left
 
@@ -13240,15 +14003,12 @@ module Prism
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void
-    def initialize(left, right, operator_loc, flags, location)
+    # def initialize: (flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location) -> void
+    def initialize(flags, left, right, operator_loc, location)
+      @flags = flags
       @left = left
       @right = right
       @operator_loc = operator_loc
-      @flags = flags
       @location = location
     end
 
@@ -13278,10 +14038,10 @@ module Prism
     # def copy: (**params) -> RangeNode
     def copy(**params)
       RangeNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:left) { left },
         params.fetch(:right) { right },
         params.fetch(:operator_loc) { operator_loc },
-        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -13290,13 +14050,8 @@ module Prism
     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)
-      { left: left, right: right, operator_loc: operator_loc, flags: flags, location: location }
-    end
-
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+    def deconstruct_keys(keys)
+      { flags: flags, left: left, right: right, operator_loc: operator_loc, location: location }
     end
 
     # def exclude_end?: () -> bool
@@ -13304,9 +14059,16 @@ module Prism
       flags.anybits?(RangeFlags::EXCLUDE_END)
     end
 
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("exclude_end" if exclude_end?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       if (left = self.left).nil?
         inspector << "├── left: ∅\n"
       else
@@ -13319,9 +14081,7 @@ module Prism
         inspector << "├── right:\n"
         inspector << right.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      flags = [("exclude_end" if exclude_end?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector.to_str
     end
 
@@ -13526,6 +14286,9 @@ module Prism
   #     /foo/i
   #     ^^^^^^
   class RegularExpressionNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
 
@@ -13538,16 +14301,13 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> void
-    def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location)
+    # def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
+    def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location)
+      @flags = flags
       @opening_loc = opening_loc
       @content_loc = content_loc
       @closing_loc = closing_loc
       @unescaped = unescaped
-      @flags = flags
       @location = location
     end
 
@@ -13574,11 +14334,11 @@ module Prism
     # def copy: (**params) -> RegularExpressionNode
     def copy(**params)
       RegularExpressionNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:content_loc) { content_loc },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:unescaped) { unescaped },
-        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -13588,22 +14348,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, flags: flags, location: location }
-    end
-
-    # def opening: () -> String
-    def opening
-      opening_loc.slice
-    end
-
-    # def content: () -> String
-    def content
-      content_loc.slice
-    end
-
-    # def closing: () -> String
-    def closing
-      closing_loc.slice
+      { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
     end
 
     # def ignore_case?: () -> bool
@@ -13646,15 +14391,45 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
+    # def forced_utf8_encoding?: () -> bool
+    def forced_utf8_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_UTF8_ENCODING)
+    end
+
+    # def forced_binary_encoding?: () -> bool
+    def forced_binary_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_BINARY_ENCODING)
+    end
+
+    # def forced_us_ascii_encoding?: () -> bool
+    def forced_us_ascii_encoding?
+      flags.anybits?(RegularExpressionFlags::FORCED_US_ASCII_ENCODING)
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def content: () -> String
+    def content
+      content_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector << "├── unescaped: #{unescaped.inspect}\n"
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "└── unescaped: #{unescaped.inspect}\n"
       inspector.to_str
     end
 
@@ -15076,100 +15851,6 @@ module Prism
     end
   end
 
-  # Represents the use of compile-time string concatenation.
-  #
-  #     "foo" "bar"
-  #     ^^^^^^^^^^^
-  class StringConcatNode < Node
-    # attr_reader left: Node
-    attr_reader :left
-
-    # attr_reader right: Node
-    attr_reader :right
-
-    # def initialize: (left: Node, right: Node, location: Location) -> void
-    def initialize(left, right, location)
-      @left = left
-      @right = right
-      @location = location
-    end
-
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_string_concat_node(self)
-    end
-
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [left, right]
-    end
-
-    # def compact_child_nodes: () -> Array[Node]
-    def compact_child_nodes
-      [left, right]
-    end
-
-    # def comment_targets: () -> Array[Node | Location]
-    def comment_targets
-      [left, right]
-    end
-
-    # def copy: (**params) -> StringConcatNode
-    def copy(**params)
-      StringConcatNode.new(
-        params.fetch(:left) { left },
-        params.fetch(:right) { right },
-        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)
-      { left: left, right: right, location: location }
-    end
-
-    # def inspect(inspector: NodeInspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── left:\n"
-      inspector << inspector.child_node(left, "│   ")
-      inspector << "└── right:\n"
-      inspector << inspector.child_node(right, "    ")
-      inspector.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
-      :string_concat_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
-      :string_concat_node
-    end
-  end
-
   # Represents a string literal, a string contained within a `%w` list, or
   # plain string content within an interpolated string.
   #
@@ -15247,6 +15928,16 @@ module Prism
       { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
     end
 
+    # def forced_utf8_encoding?: () -> bool
+    def forced_utf8_encoding?
+      flags.anybits?(StringFlags::FORCED_UTF8_ENCODING)
+    end
+
+    # def forced_binary_encoding?: () -> bool
+    def forced_binary_encoding?
+      flags.anybits?(StringFlags::FORCED_BINARY_ENCODING)
+    end
+
     # def frozen?: () -> bool
     def frozen?
       flags.anybits?(StringFlags::FROZEN)
@@ -15270,7 +15961,7 @@ module Prism
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      flags = [("frozen" if frozen?)].compact
+      flags = [("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("frozen" if frozen?)].compact
       inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
@@ -15457,6 +16148,9 @@ module Prism
   #     %i[foo]
   #        ^^^
   class SymbolNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader opening_loc: Location?
     attr_reader :opening_loc
 
@@ -15469,8 +16163,9 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-    # def initialize: (opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void
-    def initialize(opening_loc, value_loc, closing_loc, unescaped, location)
+    # def initialize: (flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void
+    def initialize(flags, opening_loc, value_loc, closing_loc, unescaped, location)
+      @flags = flags
       @opening_loc = opening_loc
       @value_loc = value_loc
       @closing_loc = closing_loc
@@ -15501,6 +16196,7 @@ module Prism
     # def copy: (**params) -> SymbolNode
     def copy(**params)
       SymbolNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:value_loc) { value_loc },
         params.fetch(:closing_loc) { closing_loc },
@@ -15514,7 +16210,22 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { opening_loc: opening_loc, value_loc: value_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
+      { flags: flags, opening_loc: opening_loc, value_loc: value_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
+    end
+
+    # def forced_utf8_encoding?: () -> bool
+    def forced_utf8_encoding?
+      flags.anybits?(SymbolFlags::FORCED_UTF8_ENCODING)
+    end
+
+    # def forced_binary_encoding?: () -> bool
+    def forced_binary_encoding?
+      flags.anybits?(SymbolFlags::FORCED_BINARY_ENCODING)
+    end
+
+    # def forced_us_ascii_encoding?: () -> bool
+    def forced_us_ascii_encoding?
+      flags.anybits?(SymbolFlags::FORCED_US_ASCII_ENCODING)
     end
 
     # def opening: () -> String?
@@ -15535,6 +16246,8 @@ module Prism
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── value_loc: #{inspector.location(value_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
@@ -15762,6 +16475,9 @@ module Prism
     # attr_reader predicate: Node
     attr_reader :predicate
 
+    # attr_reader then_keyword_loc: Location?
+    attr_reader :then_keyword_loc
+
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
@@ -15771,10 +16487,11 @@ module Prism
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
-    def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
+    # def initialize: (keyword_loc: Location, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
       @keyword_loc = keyword_loc
       @predicate = predicate
+      @then_keyword_loc = then_keyword_loc
       @statements = statements
       @consequent = consequent
       @end_keyword_loc = end_keyword_loc
@@ -15806,7 +16523,7 @@ module Prism
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [keyword_loc, predicate, *statements, *consequent, *end_keyword_loc]
+      [keyword_loc, predicate, *then_keyword_loc, *statements, *consequent, *end_keyword_loc]
     end
 
     # def copy: (**params) -> UnlessNode
@@ -15814,6 +16531,7 @@ module Prism
       UnlessNode.new(
         params.fetch(:keyword_loc) { keyword_loc },
         params.fetch(:predicate) { predicate },
+        params.fetch(:then_keyword_loc) { then_keyword_loc },
         params.fetch(:statements) { statements },
         params.fetch(:consequent) { consequent },
         params.fetch(:end_keyword_loc) { end_keyword_loc },
@@ -15826,7 +16544,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { keyword_loc: keyword_loc, predicate: predicate, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
+      { keyword_loc: keyword_loc, predicate: predicate, then_keyword_loc: then_keyword_loc, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
     end
 
     # def keyword: () -> String
@@ -15834,6 +16552,11 @@ module Prism
       keyword_loc.slice
     end
 
+    # def then_keyword: () -> String?
+    def then_keyword
+      then_keyword_loc&.slice
+    end
+
     # def end_keyword: () -> String?
     def end_keyword
       end_keyword_loc&.slice
@@ -15845,6 +16568,7 @@ module Prism
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
       inspector << "├── predicate:\n"
       inspector << inspector.child_node(predicate, "│   ")
+      inspector << "├── then_keyword_loc: #{inspector.location(then_keyword_loc)}\n"
       if (statements = self.statements).nil?
         inspector << "├── statements: ∅\n"
       else
@@ -15898,6 +16622,9 @@ module Prism
   #     until foo do bar end
   #     ^^^^^^^^^^^^^^^^^^^^
   class UntilNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader keyword_loc: Location
     attr_reader :keyword_loc
 
@@ -15910,16 +16637,13 @@ module Prism
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void
-    def initialize(keyword_loc, closing_loc, predicate, statements, flags, location)
+    # def initialize: (flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location) -> void
+    def initialize(flags, keyword_loc, closing_loc, predicate, statements, location)
+      @flags = flags
       @keyword_loc = keyword_loc
       @closing_loc = closing_loc
       @predicate = predicate
       @statements = statements
-      @flags = flags
       @location = location
     end
 
@@ -15953,11 +16677,11 @@ module Prism
     # def copy: (**params) -> UntilNode
     def copy(**params)
       UntilNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:keyword_loc) { keyword_loc },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:predicate) { predicate },
         params.fetch(:statements) { statements },
-        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -15967,7 +16691,12 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, flags: flags, location: location }
+      { flags: flags, keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, location: location }
+    end
+
+    # def begin_modifier?: () -> bool
+    def begin_modifier?
+      flags.anybits?(LoopFlags::BEGIN_MODIFIER)
     end
 
     # def keyword: () -> String
@@ -15980,26 +16709,21 @@ module Prism
       closing_loc&.slice
     end
 
-    # def begin_modifier?: () -> bool
-    def begin_modifier?
-      flags.anybits?(LoopFlags::BEGIN_MODIFIER)
-    end
-
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("begin_modifier" if begin_modifier?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       inspector << "├── predicate:\n"
       inspector << inspector.child_node(predicate, "│   ")
       if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
+        inspector << "└── statements: ∅\n"
       else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+        inspector << "└── statements:\n"
+        inspector << statements.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
       end
-      flags = [("begin_modifier" if begin_modifier?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
 
@@ -16153,6 +16877,9 @@ module Prism
   #     while foo do bar end
   #     ^^^^^^^^^^^^^^^^^^^^
   class WhileNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader keyword_loc: Location
     attr_reader :keyword_loc
 
@@ -16165,16 +16892,13 @@ module Prism
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-    # attr_reader flags: Integer
-    private attr_reader :flags
-
-    # def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void
-    def initialize(keyword_loc, closing_loc, predicate, statements, flags, location)
+    # def initialize: (flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location) -> void
+    def initialize(flags, keyword_loc, closing_loc, predicate, statements, location)
+      @flags = flags
       @keyword_loc = keyword_loc
       @closing_loc = closing_loc
       @predicate = predicate
       @statements = statements
-      @flags = flags
       @location = location
     end
 
@@ -16208,11 +16932,11 @@ module Prism
     # def copy: (**params) -> WhileNode
     def copy(**params)
       WhileNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:keyword_loc) { keyword_loc },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:predicate) { predicate },
         params.fetch(:statements) { statements },
-        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -16222,7 +16946,12 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, flags: flags, location: location }
+      { flags: flags, keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, location: location }
+    end
+
+    # def begin_modifier?: () -> bool
+    def begin_modifier?
+      flags.anybits?(LoopFlags::BEGIN_MODIFIER)
     end
 
     # def keyword: () -> String
@@ -16235,26 +16964,21 @@ module Prism
       closing_loc&.slice
     end
 
-    # def begin_modifier?: () -> bool
-    def begin_modifier?
-      flags.anybits?(LoopFlags::BEGIN_MODIFIER)
-    end
-
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("begin_modifier" if begin_modifier?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       inspector << "├── predicate:\n"
       inspector << inspector.child_node(predicate, "│   ")
       if (statements = self.statements).nil?
-        inspector << "├── statements: ∅\n"
+        inspector << "└── statements: ∅\n"
       else
-        inspector << "├── statements:\n"
-        inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+        inspector << "└── statements:\n"
+        inspector << statements.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
       end
-      flags = [("begin_modifier" if begin_modifier?)].compact
-      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
 
@@ -16292,6 +17016,9 @@ module Prism
   #     `foo`
   #     ^^^^^
   class XStringNode < Node
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
 
@@ -16304,8 +17031,9 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-    # def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
-    def initialize(opening_loc, content_loc, closing_loc, unescaped, location)
+    # def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
+    def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location)
+      @flags = flags
       @opening_loc = opening_loc
       @content_loc = content_loc
       @closing_loc = closing_loc
@@ -16336,6 +17064,7 @@ module Prism
     # def copy: (**params) -> XStringNode
     def copy(**params)
       XStringNode.new(
+        params.fetch(:flags) { flags },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:content_loc) { content_loc },
         params.fetch(:closing_loc) { closing_loc },
@@ -16349,7 +17078,17 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
+      { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
+    end
+
+    # def forced_utf8_encoding?: () -> bool
+    def forced_utf8_encoding?
+      flags.anybits?(EncodingFlags::FORCED_UTF8_ENCODING)
+    end
+
+    # def forced_binary_encoding?: () -> bool
+    def forced_binary_encoding?
+      flags.anybits?(EncodingFlags::FORCED_BINARY_ENCODING)
     end
 
     # def opening: () -> String
@@ -16370,6 +17109,8 @@ module Prism
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      flags = [("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
@@ -16535,7 +17276,13 @@ module Prism
   # Flags for arguments nodes.
   module ArgumentsNodeFlags
     # if arguments contain keyword splat
-    KEYWORD_SPLAT = 1 << 0
+    CONTAINS_KEYWORD_SPLAT = 1 << 0
+  end
+
+  # Flags for array nodes.
+  module ArrayNodeFlags
+    # if array contains splat nodes
+    CONTAINS_SPLAT = 1 << 0
   end
 
   # Flags for call nodes.
@@ -16545,6 +17292,18 @@ module Prism
 
     # a call that could have been a local variable
     VARIABLE_CALL = 1 << 1
+
+    # a call that is an attribute write, so the value being written should be returned
+    ATTRIBUTE_WRITE = 1 << 2
+  end
+
+  # Flags for nodes that have unescaped content.
+  module EncodingFlags
+    # internal bytes forced the encoding to UTF-8
+    FORCED_UTF8_ENCODING = 1 << 0
+
+    # internal bytes forced the encoding to binary
+    FORCED_BINARY_ENCODING = 1 << 1
   end
 
   # Flags for integer nodes that correspond to the base of the integer.
@@ -16552,16 +17311,22 @@ module Prism
     # 0b prefix
     BINARY = 1 << 0
 
-    # 0o or 0 prefix
-    OCTAL = 1 << 1
-
     # 0d or no prefix
-    DECIMAL = 1 << 2
+    DECIMAL = 1 << 1
+
+    # 0o or 0 prefix
+    OCTAL = 1 << 2
 
     # 0x prefix
     HEXADECIMAL = 1 << 3
   end
 
+  # Flags for keyword hash nodes.
+  module KeywordHashNodeFlags
+    # a keyword hash which only has `AssocNode` elements all with static literal keys, which means the elements can be treated as keyword arguments
+    STATIC_KEYS = 1 << 0
+  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
@@ -16599,11 +17364,38 @@ module Prism
 
     # u - forces the UTF-8 encoding
     UTF_8 = 1 << 7
+
+    # internal bytes forced the encoding to UTF-8
+    FORCED_UTF8_ENCODING = 1 << 8
+
+    # internal bytes forced the encoding to binary
+    FORCED_BINARY_ENCODING = 1 << 9
+
+    # internal bytes forced the encoding to US-ASCII
+    FORCED_US_ASCII_ENCODING = 1 << 10
   end
 
   # Flags for string nodes.
   module StringFlags
+    # internal bytes forced the encoding to UTF-8
+    FORCED_UTF8_ENCODING = 1 << 0
+
+    # internal bytes forced the encoding to binary
+    FORCED_BINARY_ENCODING = 1 << 1
+
     # frozen by virtue of a `frozen_string_literal` comment
-    FROZEN = 1 << 0
+    FROZEN = 1 << 2
+  end
+
+  # Flags for symbol nodes.
+  module SymbolFlags
+    # internal bytes forced the encoding to UTF-8
+    FORCED_UTF8_ENCODING = 1 << 0
+
+    # internal bytes forced the encoding to binary
+    FORCED_BINARY_ENCODING = 1 << 1
+
+    # internal bytes forced the encoding to US-ASCII
+    FORCED_US_ASCII_ENCODING = 1 << 2
   end
 end