prism 0.17.1 → 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
@@ -1025,6 +1111,56 @@ class Prism::CapturePatternNode < Prism::Node
   def inspect(inspector); end
 end
 
+# Represents the use of a case statement for pattern matching.
+#
+#     case true
+#     in false
+#     end
+#     ^^^^^^^^^
+class Prism::CaseMatchNode < Prism::Node
+  sig { returns(T.nilable(Prism::Node)) }
+  def predicate; end
+
+  sig { returns(T::Array[Prism::Node]) }
+  def conditions; end
+
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def consequent; end
+
+  sig { returns(Prism::Location) }
+  def case_keyword_loc; end
+
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  sig { params(predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::Node], consequent: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_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::CaseMatchNode) }
+  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(String) }
+  def case_keyword; end
+
+  sig { returns(String) }
+  def end_keyword; end
+
+  sig { params(inspector: Prism::NodeInspector).returns(String) }
+  def inspect(inspector); end
+end
+
 # Represents the use of a case statement.
 #
 #     case true
@@ -1855,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
 
@@ -1873,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
@@ -2216,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
 
@@ -2225,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
@@ -2246,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
@@ -2765,6 +2904,9 @@ class Prism::IfNode < Prism::Node
   sig { returns(Prism::Node) }
   def predicate; end
 
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; end
+
   sig { returns(T.nilable(Prism::StatementsNode)) }
   def statements; end
 
@@ -2774,8 +2916,8 @@ class Prism::IfNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def end_keyword_loc; end
 
-  sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void }
-  def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end
+  sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void }
+  def initialize(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -2797,6 +2939,9 @@ class Prism::IfNode < Prism::Node
   sig { returns(T.nilable(String)) }
   def if_keyword; end
 
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
   sig { returns(T.nilable(String)) }
   def end_keyword; end
 
@@ -2868,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
@@ -2918,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
 
@@ -2936,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
@@ -2963,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
 
@@ -2972,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
 
@@ -2990,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
 
@@ -3008,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
 
@@ -3020,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
@@ -3038,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
 
@@ -3047,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
@@ -3062,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
 
@@ -3080,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
@@ -3107,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
 
@@ -3116,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 opening; end
+
   sig { returns(String) }
-  def operator; end
+  def closing; end
 
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
@@ -3387,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
@@ -3406,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
 
@@ -3415,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
@@ -3438,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
 
@@ -3468,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
@@ -3477,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
 
@@ -3486,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
@@ -3509,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
 
@@ -3539,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
@@ -3680,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
@@ -3701,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
@@ -3753,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
 
@@ -3762,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
@@ -4054,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
 
@@ -4066,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
@@ -4087,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
 
@@ -4120,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
@@ -4211,11 +4505,11 @@ class Prism::MatchWriteNode < Prism::Node
   sig { returns(Prism::CallNode) }
   def call; end
 
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
+  sig { returns(T::Array[Prism::Node]) }
+  def targets; end
 
-  sig { params(call: Prism::CallNode, locals: T::Array[Symbol], location: Prism::Location).void }
-  def initialize(call, locals, location); end
+  sig { params(call: Prism::CallNode, targets: T::Array[Prism::Node], location: Prism::Location).void }
+  def initialize(call, targets, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -4520,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
@@ -4681,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]) }
@@ -4696,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 }
@@ -4982,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
 
@@ -4991,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
@@ -5012,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
@@ -5084,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
 
@@ -5096,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
@@ -5117,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
 
@@ -5150,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
@@ -5651,39 +5985,6 @@ class Prism::StatementsNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents the use of compile-time string concatenation.
-#
-#     "foo" "bar"
-#     ^^^^^^^^^^^
-class Prism::StringConcatNode < Prism::Node
-  sig { returns(Prism::Node) }
-  def left; end
-
-  sig { returns(Prism::Node) }
-  def right; end
-
-  sig { params(left: Prism::Node, right: Prism::Node, location: Prism::Location).void }
-  def initialize(left, right, 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::StringConcatNode) }
-  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 a string literal, a string contained within a `%w` list, or
 # plain string content within an interpolated string.
 #
@@ -5729,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
 
@@ -5807,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
 
@@ -5819,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
@@ -5837,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
 
@@ -5927,6 +6246,9 @@ class Prism::UnlessNode < Prism::Node
   sig { returns(Prism::Node) }
   def predicate; end
 
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; end
+
   sig { returns(T.nilable(Prism::StatementsNode)) }
   def statements; end
 
@@ -5936,8 +6258,8 @@ class Prism::UnlessNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def end_keyword_loc; end
 
-  sig { params(keyword_loc: Prism::Location, predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void }
-  def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end
+  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).void }
+  def initialize(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5959,6 +6281,9 @@ class Prism::UnlessNode < Prism::Node
   sig { returns(String) }
   def keyword; end
 
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
   sig { returns(T.nilable(String)) }
   def end_keyword; end
 
@@ -5974,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
 
@@ -5986,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
@@ -6009,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
@@ -6071,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
 
@@ -6083,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
@@ -6106,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
@@ -6124,6 +6449,9 @@ end
 #     `foo`
 #     ^^^^^
 class Prism::XStringNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Prism::Location) }
   def opening_loc; end
 
@@ -6136,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
@@ -6154,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
 
@@ -6219,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.
@@ -6228,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
@@ -6272,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
 
 
@@ -6366,10 +6742,18 @@ 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
   
+  # Visit a CaseMatchNode node
+  sig { params(node: Prism::CaseMatchNode).void }
+  def visit_case_match_node(node); end
+  
   # Visit a CaseNode node
   sig { params(node: Prism::CaseNode).void }
   def visit_case_node(node); end
@@ -6550,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
@@ -6566,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
@@ -6694,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
@@ -6810,10 +7206,6 @@ class Prism::Visitor < Prism::BasicVisitor
   sig { params(node: Prism::StatementsNode).void }
   def visit_statements_node(node); end
   
-  # Visit a StringConcatNode node
-  sig { params(node: Prism::StringConcatNode).void }
-  def visit_string_concat_node(node); end
-  
   # Visit a StringNode node
   sig { params(node: Prism::StringNode).void }
   def visit_string_node(node); end
@@ -6879,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
@@ -6906,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
@@ -6918,20 +7310,26 @@ 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
+  # Create a new CaseMatchNode node
+  sig { params(predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::Node], consequent: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::CaseMatchNode) }
+  def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
   # Create a new CaseNode node
   sig { params(predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::Node], consequent: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::CaseNode) }
   def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
@@ -6993,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
@@ -7017,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
@@ -7059,26 +7457,32 @@ module Prism::DSL
   sig { params(constant: T.nilable(Prism::Node), elements: T::Array[Prism::Node], rest: T.nilable(Prism::Node), opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::HashPatternNode) }
   def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location); end
   # Create a new IfNode node
-  sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::IfNode) }
-  def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end
+  sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::IfNode) }
+  def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
   # Create a new ImaginaryNode node
   sig { params(numeric: Prism::Node, location: Prism::Location).returns(Prism::ImaginaryNode) }
   def ImaginaryNode(numeric, location); end
   # 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
@@ -7101,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
@@ -7116,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
@@ -7143,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
@@ -7152,8 +7556,8 @@ module Prism::DSL
   sig { params(value: Prism::Node, pattern: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::MatchRequiredNode) }
   def MatchRequiredNode(value, pattern, operator_loc, location); end
   # Create a new MatchWriteNode node
-  sig { params(call: Prism::CallNode, locals: T::Array[Symbol], location: Prism::Location).returns(Prism::MatchWriteNode) }
-  def MatchWriteNode(call, locals, location); end
+  sig { params(call: Prism::CallNode, targets: T::Array[Prism::Node], location: Prism::Location).returns(Prism::MatchWriteNode) }
+  def MatchWriteNode(call, targets, location); end
   # Create a new MissingNode node
   sig { params(location: Prism::Location).returns(Prism::MissingNode) }
   def MissingNode(location); end
@@ -7175,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
@@ -7188,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) }
@@ -7209,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
@@ -7218,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
@@ -7262,9 +7669,6 @@ module Prism::DSL
   # Create a new StatementsNode node
   sig { params(body: T::Array[Prism::Node], location: Prism::Location).returns(Prism::StatementsNode) }
   def StatementsNode(body, location); end
-  # Create a new StringConcatNode node
-  sig { params(left: Prism::Node, right: Prism::Node, location: Prism::Location).returns(Prism::StringConcatNode) }
-  def StringConcatNode(left, right, location); end
   # Create a new StringNode node
   sig { params(flags: Integer, opening_loc: T.nilable(Prism::Location), content_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), unescaped: String, location: Prism::Location).returns(Prism::StringNode) }
   def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
@@ -7272,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
@@ -7281,20 +7685,20 @@ module Prism::DSL
   sig { params(names: T::Array[Prism::Node], keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::UndefNode) }
   def UndefNode(names, keyword_loc, location); end
   # Create a new UnlessNode node
-  sig { params(keyword_loc: Prism::Location, predicate: Prism::Node, 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, statements, consequent, end_keyword_loc, location); end
+  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