prism 0.18.0 → 0.19.0

data/rbi/prism.rbi

@@ -165,14 +165,14 @@ end
 #     return foo, bar, baz
 #            ^^^^^^^^^^^^^
 class Prism::ArgumentsNode < Prism::Node
-  sig { returns(T::Array[Prism::Node]) }
-  def arguments; end
-
   sig { returns(Integer) }
   def flags; end
 
-  sig { params(arguments: T::Array[Prism::Node], flags: Integer, location: Prism::Location).void }
-  def initialize(arguments, flags, location); end
+  sig { returns(T::Array[Prism::Node]) }
+  def arguments; end
+
+  sig { params(flags: Integer, arguments: T::Array[Prism::Node], location: Prism::Location).void }
+  def initialize(flags, arguments, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -190,7 +190,7 @@ class Prism::ArgumentsNode < Prism::Node
   def deconstruct_keys(keys); end
 
   sig { returns(T::Boolean) }
-  def keyword_splat?; end
+  def contains_keyword_splat?; end
 
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
@@ -202,6 +202,9 @@ end
 #     [1, 2, 3]
 #     ^^^^^^^^^
 class Prism::ArrayNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T::Array[Prism::Node]) }
   def elements; end
 
@@ -211,8 +214,8 @@ class Prism::ArrayNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def closing_loc; end
 
-  sig { params(elements: T::Array[Prism::Node], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).void }
-  def initialize(elements, opening_loc, closing_loc, location); end
+  sig { params(flags: Integer, elements: T::Array[Prism::Node], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).void }
+  def initialize(flags, elements, opening_loc, closing_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -229,6 +232,9 @@ class Prism::ArrayNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def contains_splat?; end
+
   sig { returns(T.nilable(String)) }
   def opening; end
 
@@ -536,7 +542,10 @@ class Prism::BlockNode < Prism::Node
   sig { returns(T::Array[Symbol]) }
   def locals; end
 
-  sig { returns(T.nilable(Prism::BlockParametersNode)) }
+  sig { returns(Integer) }
+  def locals_body_index; end
+
+  sig { returns(T.nilable(Prism::Node)) }
   def parameters; end
 
   sig { returns(T.nilable(Prism::Node)) }
@@ -548,8 +557,8 @@ class Prism::BlockNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; end
 
-  sig { params(locals: T::Array[Symbol], parameters: T.nilable(Prism::BlockParametersNode), body: T.nilable(Prism::Node), opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).void }
-  def initialize(locals, parameters, body, opening_loc, closing_loc, location); end
+  sig { params(locals: T::Array[Symbol], locals_body_index: Integer, parameters: T.nilable(Prism::Node), body: T.nilable(Prism::Node), opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(locals, locals_body_index, parameters, body, opening_loc, closing_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -706,6 +715,9 @@ end
 #     foo.bar &&= value
 #     ^^^^^^^^^^^^^^^^^
 class Prism::CallAndWriteNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def receiver; end
 
@@ -715,9 +727,6 @@ class Prism::CallAndWriteNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def message_loc; end
 
-  sig { returns(Integer) }
-  def flags; end
-
   sig { returns(Symbol) }
   def read_name; end
 
@@ -730,8 +739,8 @@ class Prism::CallAndWriteNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -748,18 +757,21 @@ class Prism::CallAndWriteNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  sig { returns(T.nilable(String)) }
-  def message; end
-
   sig { returns(T::Boolean) }
   def safe_navigation?; end
 
   sig { returns(T::Boolean) }
   def variable_call?; end
 
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  sig { returns(T.nilable(String)) }
+  def message; end
+
   sig { returns(String) }
   def operator; end
 
@@ -787,12 +799,18 @@ end
 #     foo&.bar
 #     ^^^^^^^^
 class Prism::CallNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def receiver; end
 
   sig { returns(T.nilable(Prism::Location)) }
   def call_operator_loc; end
 
+  sig { returns(Symbol) }
+  def name; end
+
   sig { returns(T.nilable(Prism::Location)) }
   def message_loc; end
 
@@ -808,14 +826,8 @@ class Prism::CallNode < Prism::Node
   sig { returns(T.nilable(Prism::Node)) }
   def block; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { returns(Symbol) }
-  def name; end
-
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), block: T.nilable(Prism::Node), flags: Integer, name: Symbol, location: Prism::Location).void }
-  def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), name: Symbol, message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), block: T.nilable(Prism::Node), location: Prism::Location).void }
+  def initialize(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -832,6 +844,15 @@ class Prism::CallNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -844,12 +865,6 @@ class Prism::CallNode < Prism::Node
   sig { returns(T.nilable(String)) }
   def closing; end
 
-  sig { returns(T::Boolean) }
-  def safe_navigation?; end
-
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -859,6 +874,9 @@ end
 #     foo.bar += baz
 #     ^^^^^^^^^^^^^^
 class Prism::CallOperatorWriteNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def receiver; end
 
@@ -868,9 +886,6 @@ class Prism::CallOperatorWriteNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def message_loc; end
 
-  sig { returns(Integer) }
-  def flags; end
-
   sig { returns(Symbol) }
   def read_name; end
 
@@ -886,8 +901,8 @@ class Prism::CallOperatorWriteNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -904,18 +919,21 @@ class Prism::CallOperatorWriteNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  sig { returns(T.nilable(String)) }
-  def message; end
-
   sig { returns(T::Boolean) }
   def safe_navigation?; end
 
   sig { returns(T::Boolean) }
   def variable_call?; end
 
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  sig { returns(T.nilable(String)) }
+  def message; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -925,6 +943,9 @@ end
 #     foo.bar ||= value
 #     ^^^^^^^^^^^^^^^^^
 class Prism::CallOrWriteNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def receiver; end
 
@@ -934,9 +955,6 @@ class Prism::CallOrWriteNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def message_loc; end
 
-  sig { returns(Integer) }
-  def flags; end
-
   sig { returns(Symbol) }
   def read_name; end
 
@@ -949,8 +967,8 @@ class Prism::CallOrWriteNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -967,20 +985,88 @@ class Prism::CallOrWriteNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
   sig { returns(T.nilable(String)) }
   def message; end
 
+  sig { returns(String) }
+  def operator; end
+
+  sig { params(inspector: Prism::NodeInspector).returns(String) }
+  def inspect(inspector); end
+end
+
+# Represents assigning to a method call.
+#
+#     foo.bar, = 1
+#     ^^^^^^^
+#
+#     begin
+#     rescue => foo.bar
+#               ^^^^^^^
+#     end
+#
+#     for foo.bar in baz do end
+#         ^^^^^^^
+class Prism::CallTargetNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
+  sig { returns(Prism::Node) }
+  def receiver; end
+
+  sig { returns(Prism::Location) }
+  def call_operator_loc; end
+
+  sig { returns(Symbol) }
+  def name; end
+
+  sig { returns(Prism::Location) }
+  def message_loc; end
+
+  sig { params(flags: Integer, receiver: Prism::Node, call_operator_loc: Prism::Location, name: Symbol, message_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, receiver, call_operator_loc, name, message_loc, location); end
+
+  sig { params(visitor: Prism::Visitor).void }
+  def accept(visitor); end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { params(params: T.untyped).returns(Prism::CallTargetNode) }
+  def copy(**params); end
+
+  sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
+  def deconstruct_keys(keys); end
+
   sig { returns(T::Boolean) }
   def safe_navigation?; end
 
   sig { returns(T::Boolean) }
   def variable_call?; end
 
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
   sig { returns(String) }
-  def operator; end
+  def call_operator; end
+
+  sig { returns(String) }
+  def message; end
 
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
@@ -1905,6 +1991,9 @@ class Prism::DefNode < Prism::Node
   sig { returns(T::Array[Symbol]) }
   def locals; end
 
+  sig { returns(Integer) }
+  def locals_body_index; end
+
   sig { returns(Prism::Location) }
   def def_keyword_loc; end
 
@@ -1923,8 +2012,8 @@ class Prism::DefNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def end_keyword_loc; end
 
-  sig { params(name: Symbol, name_loc: Prism::Location, receiver: T.nilable(Prism::Node), parameters: T.nilable(Prism::ParametersNode), body: T.nilable(Prism::Node), locals: T::Array[Symbol], def_keyword_loc: Prism::Location, operator_loc: T.nilable(Prism::Location), lparen_loc: T.nilable(Prism::Location), rparen_loc: T.nilable(Prism::Location), equal_loc: T.nilable(Prism::Location), end_keyword_loc: T.nilable(Prism::Location), location: Prism::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); end
+  sig { params(name: Symbol, name_loc: Prism::Location, receiver: T.nilable(Prism::Node), parameters: T.nilable(Prism::ParametersNode), body: T.nilable(Prism::Node), locals: T::Array[Symbol], locals_body_index: Integer, def_keyword_loc: Prism::Location, operator_loc: T.nilable(Prism::Location), lparen_loc: T.nilable(Prism::Location), rparen_loc: T.nilable(Prism::Location), equal_loc: T.nilable(Prism::Location), end_keyword_loc: T.nilable(Prism::Location), location: Prism::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); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -2266,6 +2355,9 @@ end
 #     baz if foo .. bar
 #            ^^^^^^^^^^
 class Prism::FlipFlopNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def left; end
 
@@ -2275,11 +2367,8 @@ class Prism::FlipFlopNode < Prism::Node
   sig { returns(Prism::Location) }
   def operator_loc; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { params(left: T.nilable(Prism::Node), right: T.nilable(Prism::Node), operator_loc: Prism::Location, flags: Integer, location: Prism::Location).void }
-  def initialize(left, right, operator_loc, flags, location); end
+  sig { params(flags: Integer, left: T.nilable(Prism::Node), right: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, left, right, operator_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -2296,12 +2385,12 @@ class Prism::FlipFlopNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
-  sig { returns(String) }
-  def operator; end
-
   sig { returns(T::Boolean) }
   def exclude_end?; end
 
+  sig { returns(String) }
+  def operator; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -2924,6 +3013,42 @@ class Prism::ImplicitNode < Prism::Node
   def inspect(inspector); 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 Prism::ImplicitRestNode < Prism::Node
+  sig { params(location: Prism::Location).void }
+  def initialize(location); end
+
+  sig { params(visitor: Prism::Visitor).void }
+  def accept(visitor); end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { params(params: T.untyped).returns(Prism::ImplicitRestNode) }
+  def copy(**params); end
+
+  sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
+  def deconstruct_keys(keys); end
+
+  sig { params(inspector: Prism::NodeInspector).returns(String) }
+  def inspect(inspector); end
+end
+
 # Represents the use of the `in` keyword in a case statement.
 #
 #     case a; in b then c end
@@ -2974,6 +3099,9 @@ end
 #     foo.bar[baz] &&= value
 #     ^^^^^^^^^^^^^^^^^^^^^^
 class Prism::IndexAndWriteNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def receiver; end
 
@@ -2992,17 +3120,14 @@ class Prism::IndexAndWriteNode < Prism::Node
   sig { returns(T.nilable(Prism::Node)) }
   def block; end
 
-  sig { returns(Integer) }
-  def flags; end
-
   sig { returns(Prism::Location) }
   def operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), flags: Integer, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -3019,6 +3144,15 @@ class Prism::IndexAndWriteNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -3028,12 +3162,6 @@ class Prism::IndexAndWriteNode < Prism::Node
   sig { returns(String) }
   def closing; end
 
-  sig { returns(T::Boolean) }
-  def safe_navigation?; end
-
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
   sig { returns(String) }
   def operator; end
 
@@ -3046,6 +3174,9 @@ end
 #     foo.bar[baz] += value
 #     ^^^^^^^^^^^^^^^^^^^^^
 class Prism::IndexOperatorWriteNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def receiver; end
 
@@ -3064,9 +3195,6 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { returns(T.nilable(Prism::Node)) }
   def block; end
 
-  sig { returns(Integer) }
-  def flags; end
-
   sig { returns(Symbol) }
   def operator; end
 
@@ -3076,8 +3204,8 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), flags: Integer, operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -3094,6 +3222,15 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -3103,12 +3240,6 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { returns(String) }
   def closing; end
 
-  sig { returns(T::Boolean) }
-  def safe_navigation?; end
-
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -3118,6 +3249,9 @@ end
 #     foo.bar[baz] ||= value
 #     ^^^^^^^^^^^^^^^^^^^^^^
 class Prism::IndexOrWriteNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def receiver; end
 
@@ -3136,17 +3270,14 @@ class Prism::IndexOrWriteNode < Prism::Node
   sig { returns(T.nilable(Prism::Node)) }
   def block; end
 
-  sig { returns(Integer) }
-  def flags; end
-
   sig { returns(Prism::Location) }
   def operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), flags: Integer, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -3163,6 +3294,15 @@ class Prism::IndexOrWriteNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -3172,14 +3312,76 @@ class Prism::IndexOrWriteNode < Prism::Node
   sig { returns(String) }
   def closing; end
 
+  sig { returns(String) }
+  def operator; end
+
+  sig { params(inspector: Prism::NodeInspector).returns(String) }
+  def inspect(inspector); end
+end
+
+# Represents assigning to an index.
+#
+#     foo[bar], = 1
+#     ^^^^^^^^
+#
+#     begin
+#     rescue => foo[bar]
+#               ^^^^^^^^
+#     end
+#
+#     for foo[bar] in baz do end
+#         ^^^^^^^^
+class Prism::IndexTargetNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
+  sig { returns(Prism::Node) }
+  def receiver; end
+
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  sig { params(flags: Integer, receiver: Prism::Node, opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), location: Prism::Location).void }
+  def initialize(flags, receiver, opening_loc, arguments, closing_loc, block, location); end
+
+  sig { params(visitor: Prism::Visitor).void }
+  def accept(visitor); end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { params(params: T.untyped).returns(Prism::IndexTargetNode) }
+  def copy(**params); end
+
+  sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
+  def deconstruct_keys(keys); end
+
   sig { returns(T::Boolean) }
   def safe_navigation?; end
 
   sig { returns(T::Boolean) }
   def variable_call?; end
 
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
   sig { returns(String) }
-  def operator; end
+  def opening; end
+
+  sig { returns(String) }
+  def closing; end
 
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
@@ -3443,10 +3645,10 @@ class Prism::IntegerNode < Prism::Node
   def binary?; end
 
   sig { returns(T::Boolean) }
-  def octal?; end
+  def decimal?; end
 
   sig { returns(T::Boolean) }
-  def decimal?; end
+  def octal?; end
 
   sig { returns(T::Boolean) }
   def hexadecimal?; end
@@ -3462,6 +3664,9 @@ end
 #     if /foo #{bar} baz/ then end
 #        ^^^^^^^^^^^^^^^^
 class Prism::InterpolatedMatchLastLineNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Prism::Location) }
   def opening_loc; end
 
@@ -3471,11 +3676,8 @@ class Prism::InterpolatedMatchLastLineNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { params(opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, flags: Integer, location: Prism::Location).void }
-  def initialize(opening_loc, parts, closing_loc, flags, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, opening_loc, parts, closing_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -3494,12 +3696,6 @@ class Prism::InterpolatedMatchLastLineNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
-  sig { returns(String) }
-  def opening; end
-
-  sig { returns(String) }
-  def closing; end
-
   sig { returns(T::Boolean) }
   def ignore_case?; end
 
@@ -3524,6 +3720,21 @@ class Prism::InterpolatedMatchLastLineNode < Prism::Node
   sig { returns(T::Boolean) }
   def utf_8?; end
 
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  sig { returns(String) }
+  def opening; end
+
+  sig { returns(String) }
+  def closing; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -3533,6 +3744,9 @@ end
 #     /foo #{bar} baz/
 #     ^^^^^^^^^^^^^^^^
 class Prism::InterpolatedRegularExpressionNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Prism::Location) }
   def opening_loc; end
 
@@ -3542,11 +3756,8 @@ class Prism::InterpolatedRegularExpressionNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { params(opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, flags: Integer, location: Prism::Location).void }
-  def initialize(opening_loc, parts, closing_loc, flags, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, opening_loc, parts, closing_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -3565,12 +3776,6 @@ class Prism::InterpolatedRegularExpressionNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
-  sig { returns(String) }
-  def opening; end
-
-  sig { returns(String) }
-  def closing; end
-
   sig { returns(T::Boolean) }
   def ignore_case?; end
 
@@ -3595,6 +3800,21 @@ class Prism::InterpolatedRegularExpressionNode < Prism::Node
   sig { returns(T::Boolean) }
   def utf_8?; end
 
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  sig { returns(String) }
+  def opening; end
+
+  sig { returns(String) }
+  def closing; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -3736,11 +3956,14 @@ end
 #     foo(a: b)
 #         ^^^^
 class Prism::KeywordHashNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T::Array[Prism::Node]) }
   def elements; end
 
-  sig { params(elements: T::Array[Prism::Node], location: Prism::Location).void }
-  def initialize(elements, location); end
+  sig { params(flags: Integer, elements: T::Array[Prism::Node], location: Prism::Location).void }
+  def initialize(flags, elements, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -3757,6 +3980,9 @@ class Prism::KeywordHashNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def static_keys?; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -3809,6 +4035,9 @@ class Prism::LambdaNode < Prism::Node
   sig { returns(T::Array[Symbol]) }
   def locals; end
 
+  sig { returns(Integer) }
+  def locals_body_index; end
+
   sig { returns(Prism::Location) }
   def operator_loc; end
 
@@ -3818,14 +4047,14 @@ class Prism::LambdaNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; end
 
-  sig { returns(T.nilable(Prism::BlockParametersNode)) }
+  sig { returns(T.nilable(Prism::Node)) }
   def parameters; end
 
   sig { returns(T.nilable(Prism::Node)) }
   def body; end
 
-  sig { params(locals: T::Array[Symbol], operator_loc: Prism::Location, opening_loc: Prism::Location, closing_loc: Prism::Location, parameters: T.nilable(Prism::BlockParametersNode), body: T.nilable(Prism::Node), location: Prism::Location).void }
-  def initialize(locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end
+  sig { params(locals: T::Array[Symbol], locals_body_index: Integer, operator_loc: Prism::Location, opening_loc: Prism::Location, closing_loc: Prism::Location, parameters: T.nilable(Prism::Node), body: T.nilable(Prism::Node), location: Prism::Location).void }
+  def initialize(locals, locals_body_index, operator_loc, opening_loc, closing_loc, parameters, body, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -4110,6 +4339,9 @@ end
 #     if /foo/i then end
 #        ^^^^^^
 class Prism::MatchLastLineNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Prism::Location) }
   def opening_loc; end
 
@@ -4122,11 +4354,8 @@ class Prism::MatchLastLineNode < Prism::Node
   sig { returns(String) }
   def unescaped; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { params(opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, flags: Integer, location: Prism::Location).void }
-  def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, location: Prism::Location).void }
+  def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -4143,15 +4372,6 @@ class Prism::MatchLastLineNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
-  sig { returns(String) }
-  def opening; end
-
-  sig { returns(String) }
-  def content; end
-
-  sig { returns(String) }
-  def closing; end
-
   sig { returns(T::Boolean) }
   def ignore_case?; end
 
@@ -4176,6 +4396,24 @@ class Prism::MatchLastLineNode < Prism::Node
   sig { returns(T::Boolean) }
   def utf_8?; end
 
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  sig { returns(String) }
+  def opening; end
+
+  sig { returns(String) }
+  def content; end
+
+  sig { returns(String) }
+  def closing; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -4576,6 +4814,37 @@ class Prism::NoKeywordsParameterNode < Prism::Node
   def inspect(inspector); end
 end
 
+# Represents an implicit set of parameters through the use of numbered
+# parameters within a block or lambda.
+#
+#     -> { _1 + _2 }
+#     ^^^^^^^^^^^^^^
+class Prism::NumberedParametersNode < Prism::Node
+  sig { returns(Integer) }
+  def maximum; end
+
+  sig { params(maximum: Integer, location: Prism::Location).void }
+  def initialize(maximum, location); end
+
+  sig { params(visitor: Prism::Visitor).void }
+  def accept(visitor); end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { params(params: T.untyped).returns(Prism::NumberedParametersNode) }
+  def copy(**params); end
+
+  sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
+  def deconstruct_keys(keys); end
+
+  sig { params(inspector: Prism::NodeInspector).returns(String) }
+  def inspect(inspector); end
+end
+
 # Represents reading a numbered reference to a capture in the previous match.
 #
 #     $1
@@ -4737,7 +5006,7 @@ class Prism::ParametersNode < Prism::Node
   sig { returns(T::Array[Prism::Node]) }
   def optionals; end
 
-  sig { returns(T.nilable(Prism::RestParameterNode)) }
+  sig { returns(T.nilable(Prism::Node)) }
   def rest; end
 
   sig { returns(T::Array[Prism::Node]) }
@@ -4752,7 +5021,7 @@ class Prism::ParametersNode < Prism::Node
   sig { returns(T.nilable(Prism::BlockParameterNode)) }
   def block; end
 
-  sig { params(requireds: T::Array[Prism::Node], optionals: T::Array[Prism::Node], rest: T.nilable(Prism::RestParameterNode), posts: T::Array[Prism::Node], keywords: T::Array[Prism::Node], keyword_rest: T.nilable(Prism::Node), block: T.nilable(Prism::BlockParameterNode), location: Prism::Location).void }
+  sig { params(requireds: T::Array[Prism::Node], optionals: T::Array[Prism::Node], rest: T.nilable(Prism::Node), posts: T::Array[Prism::Node], keywords: T::Array[Prism::Node], keyword_rest: T.nilable(Prism::Node), block: T.nilable(Prism::BlockParameterNode), location: Prism::Location).void }
   def initialize(requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end
 
   sig { params(visitor: Prism::Visitor).void }
@@ -5038,6 +5307,9 @@ end
 #     c if a =~ /left/ ... b =~ /right/
 #          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 class Prism::RangeNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Node)) }
   def left; end
 
@@ -5047,11 +5319,8 @@ class Prism::RangeNode < Prism::Node
   sig { returns(Prism::Location) }
   def operator_loc; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { params(left: T.nilable(Prism::Node), right: T.nilable(Prism::Node), operator_loc: Prism::Location, flags: Integer, location: Prism::Location).void }
-  def initialize(left, right, operator_loc, flags, location); end
+  sig { params(flags: Integer, left: T.nilable(Prism::Node), right: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, left, right, operator_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5068,12 +5337,12 @@ class Prism::RangeNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
-  sig { returns(String) }
-  def operator; end
-
   sig { returns(T::Boolean) }
   def exclude_end?; end
 
+  sig { returns(String) }
+  def operator; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -5140,6 +5409,9 @@ end
 #     /foo/i
 #     ^^^^^^
 class Prism::RegularExpressionNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Prism::Location) }
   def opening_loc; end
 
@@ -5152,11 +5424,8 @@ class Prism::RegularExpressionNode < Prism::Node
   sig { returns(String) }
   def unescaped; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { params(opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, flags: Integer, location: Prism::Location).void }
-  def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, location: Prism::Location).void }
+  def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5173,15 +5442,6 @@ class Prism::RegularExpressionNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
-  sig { returns(String) }
-  def opening; end
-
-  sig { returns(String) }
-  def content; end
-
-  sig { returns(String) }
-  def closing; end
-
   sig { returns(T::Boolean) }
   def ignore_case?; end
 
@@ -5206,6 +5466,24 @@ class Prism::RegularExpressionNode < Prism::Node
   sig { returns(T::Boolean) }
   def utf_8?; end
 
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  sig { returns(String) }
+  def opening; end
+
+  sig { returns(String) }
+  def content; end
+
+  sig { returns(String) }
+  def closing; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -5752,6 +6030,12 @@ class Prism::StringNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
   sig { returns(T::Boolean) }
   def frozen?; end
 
@@ -5830,6 +6114,9 @@ end
 #     %i[foo]
 #        ^^^
 class Prism::SymbolNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Prism::Location)) }
   def opening_loc; end
 
@@ -5842,8 +6129,8 @@ class Prism::SymbolNode < Prism::Node
   sig { returns(String) }
   def unescaped; end
 
-  sig { params(opening_loc: T.nilable(Prism::Location), value_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), unescaped: String, location: Prism::Location).void }
-  def initialize(opening_loc, value_loc, closing_loc, unescaped, location); end
+  sig { params(flags: Integer, opening_loc: T.nilable(Prism::Location), value_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), unescaped: String, location: Prism::Location).void }
+  def initialize(flags, opening_loc, value_loc, closing_loc, unescaped, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5860,6 +6147,15 @@ class Prism::SymbolNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
   sig { returns(T.nilable(String)) }
   def opening; end
 
@@ -6003,6 +6299,9 @@ end
 #     until foo do bar end
 #     ^^^^^^^^^^^^^^^^^^^^
 class Prism::UntilNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Prism::Location) }
   def keyword_loc; end
 
@@ -6015,11 +6314,8 @@ class Prism::UntilNode < Prism::Node
   sig { returns(T.nilable(Prism::StatementsNode)) }
   def statements; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { params(keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), flags: Integer, location: Prism::Location).void }
-  def initialize(keyword_loc, closing_loc, predicate, statements, flags, location); end
+  sig { params(flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), location: Prism::Location).void }
+  def initialize(flags, keyword_loc, closing_loc, predicate, statements, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -6038,15 +6334,15 @@ class Prism::UntilNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def begin_modifier?; end
+
   sig { returns(String) }
   def keyword; end
 
   sig { returns(T.nilable(String)) }
   def closing; end
 
-  sig { returns(T::Boolean) }
-  def begin_modifier?; end
-
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -6100,6 +6396,9 @@ end
 #     while foo do bar end
 #     ^^^^^^^^^^^^^^^^^^^^
 class Prism::WhileNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Prism::Location) }
   def keyword_loc; end
 
@@ -6112,11 +6411,8 @@ class Prism::WhileNode < Prism::Node
   sig { returns(T.nilable(Prism::StatementsNode)) }
   def statements; end
 
-  sig { returns(Integer) }
-  def flags; end
-
-  sig { params(keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), flags: Integer, location: Prism::Location).void }
-  def initialize(keyword_loc, closing_loc, predicate, statements, flags, location); end
+  sig { params(flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), location: Prism::Location).void }
+  def initialize(flags, keyword_loc, closing_loc, predicate, statements, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -6135,15 +6431,15 @@ class Prism::WhileNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def begin_modifier?; end
+
   sig { returns(String) }
   def keyword; end
 
   sig { returns(T.nilable(String)) }
   def closing; end
 
-  sig { returns(T::Boolean) }
-  def begin_modifier?; end
-
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -6153,6 +6449,9 @@ end
 #     `foo`
 #     ^^^^^
 class Prism::XStringNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Prism::Location) }
   def opening_loc; end
 
@@ -6165,8 +6464,8 @@ class Prism::XStringNode < Prism::Node
   sig { returns(String) }
   def unescaped; end
 
-  sig { params(opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, location: Prism::Location).void }
-  def initialize(opening_loc, content_loc, closing_loc, unescaped, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, location: Prism::Location).void }
+  def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -6183,6 +6482,12 @@ class Prism::XStringNode < Prism::Node
   sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
   sig { returns(String) }
   def opening; end
 
@@ -6248,7 +6553,13 @@ end
 # Flags for arguments nodes.
 module Prism::ArgumentsNodeFlags
   # if arguments contain keyword splat
-  KEYWORD_SPLAT = T.let(1 << 0, Integer)
+  CONTAINS_KEYWORD_SPLAT = T.let(1 << 0, Integer)
+end
+
+# Flags for array nodes.
+module Prism::ArrayNodeFlags
+  # if array contains splat nodes
+  CONTAINS_SPLAT = T.let(1 << 0, Integer)
 end
 
 # Flags for call nodes.
@@ -6257,20 +6568,36 @@ module Prism::CallNodeFlags
   SAFE_NAVIGATION = T.let(1 << 0, Integer)
   # a call that could have been a local variable
   VARIABLE_CALL = T.let(1 << 1, Integer)
+  # a call that is an attribute write, so the value being written should be returned
+  ATTRIBUTE_WRITE = T.let(1 << 2, Integer)
+end
+
+# Flags for nodes that have unescaped content.
+module Prism::EncodingFlags
+  # internal bytes forced the encoding to UTF-8
+  FORCED_UTF8_ENCODING = T.let(1 << 0, Integer)
+  # internal bytes forced the encoding to binary
+  FORCED_BINARY_ENCODING = T.let(1 << 1, Integer)
 end
 
 # Flags for integer nodes that correspond to the base of the integer.
 module Prism::IntegerBaseFlags
   # 0b prefix
   BINARY = T.let(1 << 0, Integer)
-  # 0o or 0 prefix
-  OCTAL = T.let(1 << 1, Integer)
   # 0d or no prefix
-  DECIMAL = T.let(1 << 2, Integer)
+  DECIMAL = T.let(1 << 1, Integer)
+  # 0o or 0 prefix
+  OCTAL = T.let(1 << 2, Integer)
   # 0x prefix
   HEXADECIMAL = T.let(1 << 3, Integer)
 end
 
+# Flags for keyword hash nodes.
+module Prism::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 = T.let(1 << 0, Integer)
+end
+
 # Flags for while and until loop nodes.
 module Prism::LoopFlags
   # a loop after a begin statement, so the body is executed first before the condition
@@ -6301,12 +6628,32 @@ module Prism::RegularExpressionFlags
   WINDOWS_31J = T.let(1 << 6, Integer)
   # u - forces the UTF-8 encoding
   UTF_8 = T.let(1 << 7, Integer)
+  # internal bytes forced the encoding to UTF-8
+  FORCED_UTF8_ENCODING = T.let(1 << 8, Integer)
+  # internal bytes forced the encoding to binary
+  FORCED_BINARY_ENCODING = T.let(1 << 9, Integer)
+  # internal bytes forced the encoding to US-ASCII
+  FORCED_US_ASCII_ENCODING = T.let(1 << 10, Integer)
 end
 
 # Flags for string nodes.
 module Prism::StringFlags
+  # internal bytes forced the encoding to UTF-8
+  FORCED_UTF8_ENCODING = T.let(1 << 0, Integer)
+  # internal bytes forced the encoding to binary
+  FORCED_BINARY_ENCODING = T.let(1 << 1, Integer)
   # frozen by virtue of a `frozen_string_literal` comment
-  FROZEN = T.let(1 << 0, Integer)
+  FROZEN = T.let(1 << 2, Integer)
+end
+
+# Flags for symbol nodes.
+module Prism::SymbolFlags
+  # internal bytes forced the encoding to UTF-8
+  FORCED_UTF8_ENCODING = T.let(1 << 0, Integer)
+  # internal bytes forced the encoding to binary
+  FORCED_BINARY_ENCODING = T.let(1 << 1, Integer)
+  # internal bytes forced the encoding to US-ASCII
+  FORCED_US_ASCII_ENCODING = T.let(1 << 2, Integer)
 end
 
 
@@ -6395,6 +6742,10 @@ class Prism::Visitor < Prism::BasicVisitor
   sig { params(node: Prism::CallOrWriteNode).void }
   def visit_call_or_write_node(node); end
   
+  # Visit a CallTargetNode node
+  sig { params(node: Prism::CallTargetNode).void }
+  def visit_call_target_node(node); end
+  
   # Visit a CapturePatternNode node
   sig { params(node: Prism::CapturePatternNode).void }
   def visit_capture_pattern_node(node); end
@@ -6583,6 +6934,10 @@ class Prism::Visitor < Prism::BasicVisitor
   sig { params(node: Prism::ImplicitNode).void }
   def visit_implicit_node(node); end
   
+  # Visit a ImplicitRestNode node
+  sig { params(node: Prism::ImplicitRestNode).void }
+  def visit_implicit_rest_node(node); end
+  
   # Visit a InNode node
   sig { params(node: Prism::InNode).void }
   def visit_in_node(node); end
@@ -6599,6 +6954,10 @@ class Prism::Visitor < Prism::BasicVisitor
   sig { params(node: Prism::IndexOrWriteNode).void }
   def visit_index_or_write_node(node); end
   
+  # Visit a IndexTargetNode node
+  sig { params(node: Prism::IndexTargetNode).void }
+  def visit_index_target_node(node); end
+  
   # Visit a InstanceVariableAndWriteNode node
   sig { params(node: Prism::InstanceVariableAndWriteNode).void }
   def visit_instance_variable_and_write_node(node); end
@@ -6727,6 +7086,10 @@ class Prism::Visitor < Prism::BasicVisitor
   sig { params(node: Prism::NoKeywordsParameterNode).void }
   def visit_no_keywords_parameter_node(node); end
   
+  # Visit a NumberedParametersNode node
+  sig { params(node: Prism::NumberedParametersNode).void }
+  def visit_numbered_parameters_node(node); end
+  
   # Visit a NumberedReferenceReadNode node
   sig { params(node: Prism::NumberedReferenceReadNode).void }
   def visit_numbered_reference_read_node(node); end
@@ -6908,11 +7271,11 @@ module Prism::DSL
   sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::AndNode) }
   def AndNode(left, right, operator_loc, location); end
   # Create a new ArgumentsNode node
-  sig { params(arguments: T::Array[Prism::Node], flags: Integer, location: Prism::Location).returns(Prism::ArgumentsNode) }
-  def ArgumentsNode(arguments, flags, location); end
+  sig { params(flags: Integer, arguments: T::Array[Prism::Node], location: Prism::Location).returns(Prism::ArgumentsNode) }
+  def ArgumentsNode(flags, arguments, location); end
   # Create a new ArrayNode node
-  sig { params(elements: T::Array[Prism::Node], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::ArrayNode) }
-  def ArrayNode(elements, opening_loc, closing_loc, location); end
+  sig { params(flags: Integer, elements: T::Array[Prism::Node], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::ArrayNode) }
+  def ArrayNode(flags, elements, opening_loc, closing_loc, location); end
   # Create a new ArrayPatternNode node
   sig { params(constant: T.nilable(Prism::Node), requireds: T::Array[Prism::Node], rest: T.nilable(Prism::Node), posts: T::Array[Prism::Node], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::ArrayPatternNode) }
   def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location); end
@@ -6935,8 +7298,8 @@ module Prism::DSL
   sig { params(name: Symbol, location: Prism::Location).returns(Prism::BlockLocalVariableNode) }
   def BlockLocalVariableNode(name, location); end
   # Create a new BlockNode node
-  sig { params(locals: T::Array[Symbol], parameters: T.nilable(Prism::BlockParametersNode), body: T.nilable(Prism::Node), opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).returns(Prism::BlockNode) }
-  def BlockNode(locals, parameters, body, opening_loc, closing_loc, location); end
+  sig { params(locals: T::Array[Symbol], locals_body_index: Integer, parameters: T.nilable(Prism::Node), body: T.nilable(Prism::Node), opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).returns(Prism::BlockNode) }
+  def BlockNode(locals, locals_body_index, parameters, body, opening_loc, closing_loc, location); end
   # Create a new BlockParameterNode node
   sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::BlockParameterNode) }
   def BlockParameterNode(name, name_loc, operator_loc, location); end
@@ -6947,17 +7310,20 @@ module Prism::DSL
   sig { params(arguments: T.nilable(Prism::ArgumentsNode), keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::BreakNode) }
   def BreakNode(arguments, keyword_loc, location); end
   # Create a new CallAndWriteNode node
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::CallAndWriteNode) }
-  def CallAndWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::CallAndWriteNode) }
+  def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
   # Create a new CallNode node
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), block: T.nilable(Prism::Node), flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::CallNode) }
-  def CallNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), name: Symbol, message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), block: T.nilable(Prism::Node), location: Prism::Location).returns(Prism::CallNode) }
+  def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location); end
   # Create a new CallOperatorWriteNode node
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::CallOperatorWriteNode) }
-  def CallOperatorWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::CallOperatorWriteNode) }
+  def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location); end
   # Create a new CallOrWriteNode node
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::CallOrWriteNode) }
-  def CallOrWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::CallOrWriteNode) }
+  def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
+  # Create a new CallTargetNode node
+  sig { params(flags: Integer, receiver: Prism::Node, call_operator_loc: Prism::Location, name: Symbol, message_loc: Prism::Location, location: Prism::Location).returns(Prism::CallTargetNode) }
+  def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, location); end
   # Create a new CapturePatternNode node
   sig { params(value: Prism::Node, target: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::CapturePatternNode) }
   def CapturePatternNode(value, target, operator_loc, location); end
@@ -7025,8 +7391,8 @@ module Prism::DSL
   sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::ConstantWriteNode) }
   def ConstantWriteNode(name, name_loc, value, operator_loc, location); end
   # Create a new DefNode node
-  sig { params(name: Symbol, name_loc: Prism::Location, receiver: T.nilable(Prism::Node), parameters: T.nilable(Prism::ParametersNode), body: T.nilable(Prism::Node), locals: T::Array[Symbol], def_keyword_loc: Prism::Location, operator_loc: T.nilable(Prism::Location), lparen_loc: T.nilable(Prism::Location), rparen_loc: T.nilable(Prism::Location), equal_loc: T.nilable(Prism::Location), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::DefNode) }
-  def DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end
+  sig { params(name: Symbol, name_loc: Prism::Location, receiver: T.nilable(Prism::Node), parameters: T.nilable(Prism::ParametersNode), body: T.nilable(Prism::Node), locals: T::Array[Symbol], locals_body_index: Integer, def_keyword_loc: Prism::Location, operator_loc: T.nilable(Prism::Location), lparen_loc: T.nilable(Prism::Location), rparen_loc: T.nilable(Prism::Location), equal_loc: T.nilable(Prism::Location), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::DefNode) }
+  def DefNode(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); end
   # Create a new DefinedNode node
   sig { params(lparen_loc: T.nilable(Prism::Location), value: Prism::Node, rparen_loc: T.nilable(Prism::Location), keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::DefinedNode) }
   def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location); end
@@ -7049,8 +7415,8 @@ module Prism::DSL
   sig { params(constant: T.nilable(Prism::Node), left: Prism::Node, requireds: T::Array[Prism::Node], right: Prism::Node, opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::FindPatternNode) }
   def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location); end
   # Create a new FlipFlopNode node
-  sig { params(left: T.nilable(Prism::Node), right: T.nilable(Prism::Node), operator_loc: Prism::Location, flags: Integer, location: Prism::Location).returns(Prism::FlipFlopNode) }
-  def FlipFlopNode(left, right, operator_loc, flags, location); end
+  sig { params(flags: Integer, left: T.nilable(Prism::Node), right: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::FlipFlopNode) }
+  def FlipFlopNode(flags, left, right, operator_loc, location); end
   # Create a new FloatNode node
   sig { params(location: Prism::Location).returns(Prism::FloatNode) }
   def FloatNode(location); end
@@ -7099,18 +7465,24 @@ module Prism::DSL
   # Create a new ImplicitNode node
   sig { params(value: Prism::Node, location: Prism::Location).returns(Prism::ImplicitNode) }
   def ImplicitNode(value, location); end
+  # Create a new ImplicitRestNode node
+  sig { params(location: Prism::Location).returns(Prism::ImplicitRestNode) }
+  def ImplicitRestNode(location); end
   # Create a new InNode node
   sig { params(pattern: Prism::Node, statements: T.nilable(Prism::StatementsNode), in_loc: Prism::Location, then_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::InNode) }
   def InNode(pattern, statements, in_loc, then_loc, location); end
   # Create a new IndexAndWriteNode node
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), flags: Integer, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::IndexAndWriteNode) }
-  def IndexAndWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::IndexAndWriteNode) }
+  def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
   # Create a new IndexOperatorWriteNode node
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), flags: Integer, operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::IndexOperatorWriteNode) }
-  def IndexOperatorWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::IndexOperatorWriteNode) }
+  def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location); end
   # Create a new IndexOrWriteNode node
-  sig { params(receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), flags: Integer, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::IndexOrWriteNode) }
-  def IndexOrWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::IndexOrWriteNode) }
+  def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
+  # Create a new IndexTargetNode node
+  sig { params(flags: Integer, receiver: Prism::Node, opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), location: Prism::Location).returns(Prism::IndexTargetNode) }
+  def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, location); end
   # Create a new InstanceVariableAndWriteNode node
   sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::InstanceVariableAndWriteNode) }
   def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location); end
@@ -7133,11 +7505,11 @@ module Prism::DSL
   sig { params(flags: Integer, location: Prism::Location).returns(Prism::IntegerNode) }
   def IntegerNode(flags, location); end
   # Create a new InterpolatedMatchLastLineNode node
-  sig { params(opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, flags: Integer, location: Prism::Location).returns(Prism::InterpolatedMatchLastLineNode) }
-  def InterpolatedMatchLastLineNode(opening_loc, parts, closing_loc, flags, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, location: Prism::Location).returns(Prism::InterpolatedMatchLastLineNode) }
+  def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, location); end
   # Create a new InterpolatedRegularExpressionNode node
-  sig { params(opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, flags: Integer, location: Prism::Location).returns(Prism::InterpolatedRegularExpressionNode) }
-  def InterpolatedRegularExpressionNode(opening_loc, parts, closing_loc, flags, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, location: Prism::Location).returns(Prism::InterpolatedRegularExpressionNode) }
+  def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, location); end
   # Create a new InterpolatedStringNode node
   sig { params(opening_loc: T.nilable(Prism::Location), parts: T::Array[Prism::Node], closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::InterpolatedStringNode) }
   def InterpolatedStringNode(opening_loc, parts, closing_loc, location); end
@@ -7148,14 +7520,14 @@ module Prism::DSL
   sig { params(opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, location: Prism::Location).returns(Prism::InterpolatedXStringNode) }
   def InterpolatedXStringNode(opening_loc, parts, closing_loc, location); end
   # Create a new KeywordHashNode node
-  sig { params(elements: T::Array[Prism::Node], location: Prism::Location).returns(Prism::KeywordHashNode) }
-  def KeywordHashNode(elements, location); end
+  sig { params(flags: Integer, elements: T::Array[Prism::Node], location: Prism::Location).returns(Prism::KeywordHashNode) }
+  def KeywordHashNode(flags, elements, location); end
   # Create a new KeywordRestParameterNode node
   sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::KeywordRestParameterNode) }
   def KeywordRestParameterNode(name, name_loc, operator_loc, location); end
   # Create a new LambdaNode node
-  sig { params(locals: T::Array[Symbol], operator_loc: Prism::Location, opening_loc: Prism::Location, closing_loc: Prism::Location, parameters: T.nilable(Prism::BlockParametersNode), body: T.nilable(Prism::Node), location: Prism::Location).returns(Prism::LambdaNode) }
-  def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end
+  sig { params(locals: T::Array[Symbol], locals_body_index: Integer, operator_loc: Prism::Location, opening_loc: Prism::Location, closing_loc: Prism::Location, parameters: T.nilable(Prism::Node), body: T.nilable(Prism::Node), location: Prism::Location).returns(Prism::LambdaNode) }
+  def LambdaNode(locals, locals_body_index, operator_loc, opening_loc, closing_loc, parameters, body, location); end
   # Create a new LocalVariableAndWriteNode node
   sig { params(name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableAndWriteNode) }
   def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location); end
@@ -7175,8 +7547,8 @@ module Prism::DSL
   sig { params(name: Symbol, depth: Integer, name_loc: Prism::Location, value: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::LocalVariableWriteNode) }
   def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location); end
   # Create a new MatchLastLineNode node
-  sig { params(opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, flags: Integer, location: Prism::Location).returns(Prism::MatchLastLineNode) }
-  def MatchLastLineNode(opening_loc, content_loc, closing_loc, unescaped, flags, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, location: Prism::Location).returns(Prism::MatchLastLineNode) }
+  def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
   # Create a new MatchPredicateNode node
   sig { params(value: Prism::Node, pattern: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::MatchPredicateNode) }
   def MatchPredicateNode(value, pattern, operator_loc, location); end
@@ -7207,6 +7579,9 @@ module Prism::DSL
   # Create a new NoKeywordsParameterNode node
   sig { params(operator_loc: Prism::Location, keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::NoKeywordsParameterNode) }
   def NoKeywordsParameterNode(operator_loc, keyword_loc, location); end
+  # Create a new NumberedParametersNode node
+  sig { params(maximum: Integer, location: Prism::Location).returns(Prism::NumberedParametersNode) }
+  def NumberedParametersNode(maximum, location); end
   # Create a new NumberedReferenceReadNode node
   sig { params(number: Integer, location: Prism::Location).returns(Prism::NumberedReferenceReadNode) }
   def NumberedReferenceReadNode(number, location); end
@@ -7220,7 +7595,7 @@ module Prism::DSL
   sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::OrNode) }
   def OrNode(left, right, operator_loc, location); end
   # Create a new ParametersNode node
-  sig { params(requireds: T::Array[Prism::Node], optionals: T::Array[Prism::Node], rest: T.nilable(Prism::RestParameterNode), posts: T::Array[Prism::Node], keywords: T::Array[Prism::Node], keyword_rest: T.nilable(Prism::Node), block: T.nilable(Prism::BlockParameterNode), location: Prism::Location).returns(Prism::ParametersNode) }
+  sig { params(requireds: T::Array[Prism::Node], optionals: T::Array[Prism::Node], rest: T.nilable(Prism::Node), posts: T::Array[Prism::Node], keywords: T::Array[Prism::Node], keyword_rest: T.nilable(Prism::Node), block: T.nilable(Prism::BlockParameterNode), location: Prism::Location).returns(Prism::ParametersNode) }
   def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end
   # Create a new ParenthesesNode node
   sig { params(body: T.nilable(Prism::Node), opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).returns(Prism::ParenthesesNode) }
@@ -7241,8 +7616,8 @@ module Prism::DSL
   sig { params(locals: T::Array[Symbol], statements: Prism::StatementsNode, location: Prism::Location).returns(Prism::ProgramNode) }
   def ProgramNode(locals, statements, location); end
   # Create a new RangeNode node
-  sig { params(left: T.nilable(Prism::Node), right: T.nilable(Prism::Node), operator_loc: Prism::Location, flags: Integer, location: Prism::Location).returns(Prism::RangeNode) }
-  def RangeNode(left, right, operator_loc, flags, location); end
+  sig { params(flags: Integer, left: T.nilable(Prism::Node), right: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::RangeNode) }
+  def RangeNode(flags, left, right, operator_loc, location); end
   # Create a new RationalNode node
   sig { params(numeric: Prism::Node, location: Prism::Location).returns(Prism::RationalNode) }
   def RationalNode(numeric, location); end
@@ -7250,8 +7625,8 @@ module Prism::DSL
   sig { params(location: Prism::Location).returns(Prism::RedoNode) }
   def RedoNode(location); end
   # Create a new RegularExpressionNode node
-  sig { params(opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, flags: Integer, location: Prism::Location).returns(Prism::RegularExpressionNode) }
-  def RegularExpressionNode(opening_loc, content_loc, closing_loc, unescaped, flags, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, location: Prism::Location).returns(Prism::RegularExpressionNode) }
+  def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
   # Create a new RequiredKeywordParameterNode node
   sig { params(name: Symbol, name_loc: Prism::Location, location: Prism::Location).returns(Prism::RequiredKeywordParameterNode) }
   def RequiredKeywordParameterNode(name, name_loc, location); end
@@ -7301,8 +7676,8 @@ module Prism::DSL
   sig { params(keyword_loc: Prism::Location, lparen_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), rparen_loc: T.nilable(Prism::Location), block: T.nilable(Prism::Node), location: Prism::Location).returns(Prism::SuperNode) }
   def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end
   # Create a new SymbolNode node
-  sig { params(opening_loc: T.nilable(Prism::Location), value_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), unescaped: String, location: Prism::Location).returns(Prism::SymbolNode) }
-  def SymbolNode(opening_loc, value_loc, closing_loc, unescaped, location); end
+  sig { params(flags: Integer, opening_loc: T.nilable(Prism::Location), value_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), unescaped: String, location: Prism::Location).returns(Prism::SymbolNode) }
+  def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, location); end
   # Create a new TrueNode node
   sig { params(location: Prism::Location).returns(Prism::TrueNode) }
   def TrueNode(location); end
@@ -7313,17 +7688,17 @@ module Prism::DSL
   sig { params(keyword_loc: Prism::Location, predicate: Prism::Node, then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::UnlessNode) }
   def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
   # Create a new UntilNode node
-  sig { params(keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), flags: Integer, location: Prism::Location).returns(Prism::UntilNode) }
-  def UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location); end
+  sig { params(flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), location: Prism::Location).returns(Prism::UntilNode) }
+  def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, location); end
   # Create a new WhenNode node
   sig { params(keyword_loc: Prism::Location, conditions: T::Array[Prism::Node], statements: T.nilable(Prism::StatementsNode), location: Prism::Location).returns(Prism::WhenNode) }
   def WhenNode(keyword_loc, conditions, statements, location); end
   # Create a new WhileNode node
-  sig { params(keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), flags: Integer, location: Prism::Location).returns(Prism::WhileNode) }
-  def WhileNode(keyword_loc, closing_loc, predicate, statements, flags, location); end
+  sig { params(flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), location: Prism::Location).returns(Prism::WhileNode) }
+  def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, location); end
   # Create a new XStringNode node
-  sig { params(opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, location: Prism::Location).returns(Prism::XStringNode) }
-  def XStringNode(opening_loc, content_loc, closing_loc, unescaped, location); end
+  sig { params(flags: Integer, opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String, location: Prism::Location).returns(Prism::XStringNode) }
+  def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
   # Create a new YieldNode node
   sig { params(keyword_loc: Prism::Location, lparen_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), rparen_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::YieldNode) }
   def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location); end