prism 0.18.0 → 0.19.0

data/lib/prism/node.rb

@@ -470,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
 
@@ -506,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
@@ -517,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
 
@@ -569,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
 
@@ -578,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
@@ -609,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 },
@@ -621,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?
@@ -637,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"
@@ -1482,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?
@@ -1494,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
@@ -1531,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 },
@@ -1544,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
@@ -1561,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
@@ -1950,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
 
@@ -1959,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
 
@@ -1974,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
@@ -2013,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 },
@@ -2030,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
@@ -2053,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
@@ -2061,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
@@ -2069,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"
@@ -2128,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
 
@@ -2149,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
 
@@ -2196,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
@@ -2214,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?
@@ -2237,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
@@ -2257,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?
@@ -2267,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
 
@@ -2312,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
 
@@ -2321,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
 
@@ -2339,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
@@ -2379,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 },
@@ -2397,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
@@ -2420,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
@@ -2431,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"
@@ -2476,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
 
@@ -2485,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
 
@@ -2500,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
@@ -2539,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 },
@@ -2556,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
@@ -2579,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
@@ -2587,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
@@ -2595,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"
@@ -2634,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
@@ -2691,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
 
@@ -2725,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
@@ -2735,13 +2813,118 @@ module Prism
     #
     # def self.type: () -> Symbol
     def self.type
-      :capture_pattern_node
+      :call_target_node
     end
   end
 
-  # Represents the use of a case statement for pattern matching.
+  # Represents assigning to a local variable in pattern matching.
   #
-  #     case true
+  #     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
   #     ^^^^^^^^^
@@ -5070,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
 
@@ -5088,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
@@ -5138,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 },
@@ -5153,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
@@ -5210,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"
@@ -6044,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
 
@@ -6053,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
 
@@ -6091,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
@@ -6104,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
@@ -6117,9 +6301,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
@@ -6132,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
 
@@ -7845,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
@@ -7973,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
 
@@ -7991,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
@@ -8042,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 },
@@ -8060,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?
@@ -8078,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
@@ -8096,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
@@ -8117,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, "    ")
@@ -8159,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
 
@@ -8177,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
 
@@ -8189,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
@@ -8232,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 },
@@ -8251,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?
@@ -8269,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
@@ -8303,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"
@@ -8346,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
 
@@ -8364,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
@@ -8415,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 },
@@ -8433,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?
@@ -8451,6 +8754,159 @@ module Prism
       closing_loc.slice
     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 = [("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
+        inspector << "├── receiver:\n"
+        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
+      if (arguments = self.arguments).nil?
+        inspector << "├── arguments: ∅\n"
+      else
+        inspector << "├── arguments:\n"
+        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
+      if (block = self.block).nil?
+        inspector << "├── block: ∅\n"
+      else
+        inspector << "├── block:\n"
+        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── value:\n"
+      inspector << inspector.child_node(value, "    ")
+      inspector.to_str
+    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)
@@ -8461,21 +8917,28 @@ module Prism
       flags.anybits?(CallNodeFlags::VARIABLE_CALL)
     end
 
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+    # 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)
-      if (receiver = self.receiver).nil?
-        inspector << "├── receiver: ∅\n"
-      else
-        inspector << "├── receiver:\n"
-        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      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"
@@ -8485,16 +8948,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 << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── value:\n"
-      inspector << inspector.child_node(value, "    ")
       inspector.to_str
     end
 
@@ -8513,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
@@ -8523,7 +8981,7 @@ module Prism
     #
     # def self.type: () -> Symbol
     def self.type
-      :index_or_write_node
+      :index_target_node
     end
   end
 
@@ -9195,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)
@@ -9213,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
@@ -9254,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
 
@@ -9263,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
 
@@ -9303,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
@@ -9316,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
@@ -9369,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
 
@@ -9414,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
 
@@ -9423,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
 
@@ -9463,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
@@ -9476,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
@@ -9529,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
 
@@ -9913,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
@@ -9945,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 },
       )
@@ -9955,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
@@ -10110,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
 
@@ -10119,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
@@ -10163,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 },
@@ -10177,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
@@ -10199,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"
@@ -10904,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
 
@@ -10916,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
 
@@ -10952,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
@@ -10966,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
@@ -11024,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
 
@@ -11975,7 +12496,96 @@ module Prism
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_nil_node(self)
+      visitor.visit_nil_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) -> NilNode
+    def copy(**params)
+      NilNode.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
+      :nil_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
+      :nil_node
+    end
+  end
+
+  # Represents the use of `**nil` inside method arguments.
+  #
+  #     def a(**nil)
+  #           ^^^^^
+  #     end
+  class NoKeywordsParameterNode < Node
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # attr_reader keyword_loc: Location
+    attr_reader :keyword_loc
+
+    # def initialize: (operator_loc: Location, keyword_loc: Location, location: Location) -> void
+    def initialize(operator_loc, keyword_loc, location)
+      @operator_loc = operator_loc
+      @keyword_loc = keyword_loc
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_no_keywords_parameter_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -11990,12 +12600,14 @@ module Prism
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      []
+      [operator_loc, keyword_loc]
     end
 
-    # def copy: (**params) -> NilNode
+    # def copy: (**params) -> NoKeywordsParameterNode
     def copy(**params)
-      NilNode.new(
+      NoKeywordsParameterNode.new(
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:keyword_loc) { keyword_loc },
         params.fetch(:location) { location },
       )
     end
@@ -12005,12 +12617,24 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { location: location }
+      { operator_loc: operator_loc, keyword_loc: keyword_loc, location: location }
+    end
+
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
+    # def keyword: () -> String
+    def keyword
+      keyword_loc.slice
     end
 
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
       inspector.to_str
     end
 
@@ -12029,7 +12653,7 @@ module Prism
     #
     # def type: () -> Symbol
     def type
-      :nil_node
+      :no_keywords_parameter_node
     end
 
     # Similar to #type, this method returns a symbol that you can use for
@@ -12039,32 +12663,28 @@ module Prism
     #
     # def self.type: () -> Symbol
     def self.type
-      :nil_node
+      :no_keywords_parameter_node
     end
   end
 
-  # Represents the use of `**nil` inside method arguments.
+  # Represents an implicit set of parameters through the use of numbered
+  # parameters within a block or lambda.
   #
-  #     def a(**nil)
-  #           ^^^^^
-  #     end
-  class NoKeywordsParameterNode < Node
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-
-    # attr_reader keyword_loc: Location
-    attr_reader :keyword_loc
+  #     -> { _1 + _2 }
+  #     ^^^^^^^^^^^^^^
+  class NumberedParametersNode < Node
+    # attr_reader maximum: Integer
+    attr_reader :maximum
 
-    # def initialize: (operator_loc: Location, keyword_loc: Location, location: Location) -> void
-    def initialize(operator_loc, keyword_loc, location)
-      @operator_loc = operator_loc
-      @keyword_loc = keyword_loc
+    # 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_no_keywords_parameter_node(self)
+      visitor.visit_numbered_parameters_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -12079,14 +12699,13 @@ module Prism
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [operator_loc, keyword_loc]
+      []
     end
 
-    # def copy: (**params) -> NoKeywordsParameterNode
+    # def copy: (**params) -> NumberedParametersNode
     def copy(**params)
-      NoKeywordsParameterNode.new(
-        params.fetch(:operator_loc) { operator_loc },
-        params.fetch(:keyword_loc) { keyword_loc },
+      NumberedParametersNode.new(
+        params.fetch(:maximum) { maximum },
         params.fetch(:location) { location },
       )
     end
@@ -12096,24 +12715,13 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { operator_loc: operator_loc, keyword_loc: keyword_loc, location: location }
-    end
-
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
-    end
-
-    # def keyword: () -> String
-    def keyword
-      keyword_loc.slice
+      { maximum: maximum, location: location }
     end
 
     # def inspect(inspector: NodeInspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
-      inspector << "└── keyword_loc: #{inspector.location(keyword_loc)}\n"
+      inspector << "└── maximum: #{maximum.inspect}\n"
       inspector.to_str
     end
 
@@ -12132,7 +12740,7 @@ module Prism
     #
     # def type: () -> Symbol
     def type
-      :no_keywords_parameter_node
+      :numbered_parameters_node
     end
 
     # Similar to #type, this method returns a symbol that you can use for
@@ -12142,7 +12750,7 @@ module Prism
     #
     # def self.type: () -> Symbol
     def self.type
-      :no_keywords_parameter_node
+      :numbered_parameters_node
     end
   end
 
@@ -12560,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]
@@ -12575,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
@@ -13383,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
 
@@ -13392,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
 
@@ -13430,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
@@ -13443,12 +14051,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
@@ -13456,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
@@ -13471,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
 
@@ -13678,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
 
@@ -13690,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
 
@@ -13726,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
@@ -13740,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
@@ -13798,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
 
@@ -15305,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)
@@ -15328,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"
@@ -15515,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
 
@@ -15527,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
@@ -15559,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 },
@@ -15572,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?
@@ -15593,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"
@@ -15967,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
 
@@ -15979,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
 
@@ -16022,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
@@ -16036,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
@@ -16049,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
 
@@ -16222,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
 
@@ -16234,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
 
@@ -16277,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
@@ -16291,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
@@ -16304,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
 
@@ -16361,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
 
@@ -16373,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
@@ -16405,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 },
@@ -16418,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
@@ -16439,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"
@@ -16604,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.
@@ -16614,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.
@@ -16621,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
@@ -16668,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