prism 0.19.0 → 0.20.0

data/rbi/prism.rbi

@@ -196,8 +196,7 @@ class Prism::ArgumentsNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents an array literal. This can be a regular array using brackets or
-# a special array using % like %w or %i.
+# Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
 #
 #     [1, 2, 3]
 #     ^^^^^^^^^
@@ -316,13 +315,13 @@ class Prism::AssocNode < Prism::Node
   sig { returns(Prism::Node) }
   def key; end
 
-  sig { returns(T.nilable(Prism::Node)) }
+  sig { returns(Prism::Node) }
   def value; end
 
   sig { returns(T.nilable(Prism::Location)) }
   def operator_loc; end
 
-  sig { params(key: Prism::Node, value: T.nilable(Prism::Node), operator_loc: T.nilable(Prism::Location), location: Prism::Location).void }
+  sig { params(key: Prism::Node, value: Prism::Node, operator_loc: T.nilable(Prism::Location), location: Prism::Location).void }
   def initialize(key, value, operator_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
@@ -509,11 +508,14 @@ end
 #     a { |; b| }
 #            ^
 class Prism::BlockLocalVariableNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Symbol) }
   def name; end
 
-  sig { params(name: Symbol, location: Prism::Location).void }
-  def initialize(name, location); end
+  sig { params(flags: Integer, name: Symbol, location: Prism::Location).void }
+  def initialize(flags, name, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -530,21 +532,21 @@ class Prism::BlockLocalVariableNode < 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 repeated_parameter?; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
 
 # Represents a block of ruby code.
 #
-# [1, 2, 3].each { |i| puts x }
-#                ^^^^^^^^^^^^^^
+#     [1, 2, 3].each { |i| puts x }
+#                    ^^^^^^^^^^^^^^
 class Prism::BlockNode < Prism::Node
   sig { returns(T::Array[Symbol]) }
   def locals; end
 
-  sig { returns(Integer) }
-  def locals_body_index; end
-
   sig { returns(T.nilable(Prism::Node)) }
   def parameters; end
 
@@ -557,8 +559,8 @@ class Prism::BlockNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; 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(locals: T::Array[Symbol], 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, parameters, body, opening_loc, closing_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -591,6 +593,9 @@ end
 #           ^^
 #     end
 class Prism::BlockParameterNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Symbol)) }
   def name; end
 
@@ -600,8 +605,8 @@ class Prism::BlockParameterNode < Prism::Node
   sig { returns(Prism::Location) }
   def operator_loc; end
 
-  sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).void }
-  def initialize(name, name_loc, operator_loc, location); end
+  sig { params(flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, name, name_loc, operator_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -618,6 +623,9 @@ class Prism::BlockParameterNode < 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 repeated_parameter?; end
+
   sig { returns(String) }
   def operator; end
 
@@ -766,6 +774,9 @@ class Prism::CallAndWriteNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -853,6 +864,9 @@ class Prism::CallNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -928,6 +942,9 @@ class Prism::CallOperatorWriteNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -994,6 +1011,9 @@ class Prism::CallOrWriteNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -1062,6 +1082,9 @@ class Prism::CallTargetNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(String) }
   def call_operator; end
 
@@ -1991,9 +2014,6 @@ 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
 
@@ -2012,8 +2032,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], 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(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(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -2979,14 +2999,16 @@ class Prism::ImaginaryNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents a node that is implicitly being added to the tree but doesn't
-# correspond directly to a node in the source.
+# Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
 #
 #     { foo: }
 #       ^^^^
 #
 #     { Foo: }
 #       ^^^^
+#
+#     foo in { bar: }
+#              ^^^^
 class Prism::ImplicitNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
@@ -3153,6 +3175,9 @@ class Prism::IndexAndWriteNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -3231,6 +3256,9 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -3303,6 +3331,9 @@ class Prism::IndexOrWriteNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(T.nilable(String)) }
   def call_operator; end
 
@@ -3377,6 +3408,9 @@ class Prism::IndexTargetNode < Prism::Node
   sig { returns(T::Boolean) }
   def attribute_write?; end
 
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
   sig { returns(String) }
   def opening; end
 
@@ -3657,9 +3691,7 @@ class Prism::IntegerNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents a regular expression literal that contains interpolation that
-# is being used in the predicate of a conditional to implicitly match
-# against the last line read by an IO object.
+# Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
 #
 #     if /foo #{bar} baz/ then end
 #        ^^^^^^^^^^^^^^^^
@@ -3981,7 +4013,7 @@ class Prism::KeywordHashNode < Prism::Node
   def deconstruct_keys(keys); end
 
   sig { returns(T::Boolean) }
-  def static_keys?; end
+  def symbol_keys?; end
 
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
@@ -3993,6 +4025,9 @@ end
 #           ^^^
 #     end
 class Prism::KeywordRestParameterNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Symbol)) }
   def name; end
 
@@ -4002,8 +4037,8 @@ class Prism::KeywordRestParameterNode < Prism::Node
   sig { returns(Prism::Location) }
   def operator_loc; end
 
-  sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).void }
-  def initialize(name, name_loc, operator_loc, location); end
+  sig { params(flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, name, name_loc, operator_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -4020,6 +4055,9 @@ class Prism::KeywordRestParameterNode < 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 repeated_parameter?; end
+
   sig { returns(String) }
   def operator; end
 
@@ -4035,9 +4073,6 @@ 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
 
@@ -4053,8 +4088,8 @@ class Prism::LambdaNode < Prism::Node
   sig { returns(T.nilable(Prism::Node)) }
   def body; 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(locals: T::Array[Symbol], 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, operator_loc, opening_loc, closing_loc, parameters, body, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -4219,9 +4254,7 @@ class Prism::LocalVariableOrWriteNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents reading a local variable. Note that this requires that a local
-# variable of the same name has already been written to in the same scope,
-# otherwise it is parsed as a method call.
+# Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
 #
 #     foo
 #     ^^^
@@ -4332,9 +4365,7 @@ class Prism::LocalVariableWriteNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents a regular expression literal used in the predicate of a
-# conditional to implicitly match against the last line read by an IO
-# object.
+# Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
 #
 #     if /foo/i then end
 #        ^^^^^^
@@ -4496,8 +4527,7 @@ class Prism::MatchRequiredNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents writing local variables using a regular expression match with
-# named capture groups.
+# Represents writing local variables using a regular expression match with named capture groups.
 #
 #     /(?<foo>bar)/ =~ baz
 #     ^^^^^^^^^^^^^^^^^^^^
@@ -4530,8 +4560,7 @@ class Prism::MatchWriteNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents a node that is missing from the source and results in a syntax
-# error.
+# Represents a node that is missing from the source and results in a syntax error.
 class Prism::MissingNode < Prism::Node
   sig { params(location: Prism::Location).void }
   def initialize(location); end
@@ -4814,8 +4843,7 @@ 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.
+# Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
 #
 #     -> { _1 + _2 }
 #     ^^^^^^^^^^^^^^
@@ -4881,6 +4909,9 @@ end
 #           ^^^^
 #     end
 class Prism::OptionalKeywordParameterNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Symbol) }
   def name; end
 
@@ -4890,8 +4921,8 @@ class Prism::OptionalKeywordParameterNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(name, name_loc, value, location); end
+  sig { params(flags: Integer, name: Symbol, name_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(flags, name, name_loc, value, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -4908,6 +4939,9 @@ class Prism::OptionalKeywordParameterNode < 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 repeated_parameter?; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -4918,6 +4952,9 @@ end
 #           ^^^^^
 #     end
 class Prism::OptionalParameterNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Symbol) }
   def name; end
 
@@ -4930,8 +4967,8 @@ class Prism::OptionalParameterNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(name, name_loc, operator_loc, value, location); end
+  sig { params(flags: Integer, name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(flags, name, name_loc, operator_loc, value, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -4948,6 +4985,9 @@ class Prism::OptionalParameterNode < 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 repeated_parameter?; end
+
   sig { returns(String) }
   def operator; end
 
@@ -5087,8 +5127,7 @@ class Prism::ParenthesesNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents the use of the `^` operator for pinning an expression in a
-# pattern matching expression.
+# Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
 #
 #     foo in ^(bar)
 #            ^^^^^^
@@ -5136,8 +5175,7 @@ class Prism::PinnedExpressionNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents the use of the `^` operator for pinning a variable in a pattern
-# matching expression.
+# Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
 #
 #     foo in ^bar
 #            ^^^^
@@ -5494,14 +5532,17 @@ end
 #           ^^
 #     end
 class Prism::RequiredKeywordParameterNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Symbol) }
   def name; end
 
   sig { returns(Prism::Location) }
   def name_loc; end
 
-  sig { params(name: Symbol, name_loc: Prism::Location, location: Prism::Location).void }
-  def initialize(name, name_loc, location); end
+  sig { params(flags: Integer, name: Symbol, name_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, name, name_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5518,6 +5559,9 @@ class Prism::RequiredKeywordParameterNode < 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 repeated_parameter?; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -5528,11 +5572,14 @@ end
 #           ^
 #     end
 class Prism::RequiredParameterNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(Symbol) }
   def name; end
 
-  sig { params(name: Symbol, location: Prism::Location).void }
-  def initialize(name, location); end
+  sig { params(flags: Integer, name: Symbol, location: Prism::Location).void }
+  def initialize(flags, name, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5549,6 +5596,9 @@ class Prism::RequiredParameterNode < 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 repeated_parameter?; end
+
   sig { params(inspector: Prism::NodeInspector).returns(String) }
   def inspect(inspector); end
 end
@@ -5602,8 +5652,7 @@ end
 #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 #     end
 #
-# `Foo, *splat, Bar` are in the `exceptions` field.
-# `ex` is in the `exception` field.
+# `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `exception` field.
 class Prism::RescueNode < Prism::Node
   sig { returns(Prism::Location) }
   def keyword_loc; end
@@ -5657,6 +5706,9 @@ end
 #           ^^
 #     end
 class Prism::RestParameterNode < Prism::Node
+  sig { returns(Integer) }
+  def flags; end
+
   sig { returns(T.nilable(Symbol)) }
   def name; end
 
@@ -5666,8 +5718,8 @@ class Prism::RestParameterNode < Prism::Node
   sig { returns(Prism::Location) }
   def operator_loc; end
 
-  sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).void }
-  def initialize(name, name_loc, operator_loc, location); end
+  sig { params(flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(flags, name, name_loc, operator_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5684,6 +5736,9 @@ class Prism::RestParameterNode < 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 repeated_parameter?; end
+
   sig { returns(String) }
   def operator; end
 
@@ -5985,8 +6040,7 @@ class Prism::StatementsNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents a string literal, a string contained within a `%w` list, or
-# plain string content within an interpolated string.
+# Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
 #
 #     "foo"
 #     ^^^^^
@@ -6570,6 +6624,8 @@ module Prism::CallNodeFlags
   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)
+  # a call that ignores method visibility
+  IGNORE_VISIBILITY = T.let(1 << 3, Integer)
 end
 
 # Flags for nodes that have unescaped content.
@@ -6594,8 +6650,8 @@ 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)
+  # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments
+  SYMBOL_KEYS = T.let(1 << 0, Integer)
 end
 
 # Flags for while and until loop nodes.
@@ -6604,6 +6660,12 @@ module Prism::LoopFlags
   BEGIN_MODIFIER = T.let(1 << 0, Integer)
 end
 
+# Flags for parameter nodes.
+module Prism::ParameterFlags
+  # a parameter name that has been repeated in the method signature
+  REPEATED_PARAMETER = T.let(1 << 0, Integer)
+end
+
 # Flags for range and flip-flop nodes.
 module Prism::RangeFlags
   # ... operator
@@ -7280,7 +7342,7 @@ module Prism::DSL
   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
   # Create a new AssocNode node
-  sig { params(key: Prism::Node, value: T.nilable(Prism::Node), operator_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::AssocNode) }
+  sig { params(key: Prism::Node, value: Prism::Node, operator_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::AssocNode) }
   def AssocNode(key, value, operator_loc, location); end
   # Create a new AssocSplatNode node
   sig { params(value: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::AssocSplatNode) }
@@ -7295,14 +7357,14 @@ module Prism::DSL
   sig { params(expression: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::BlockArgumentNode) }
   def BlockArgumentNode(expression, operator_loc, location); end
   # Create a new BlockLocalVariableNode node
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::BlockLocalVariableNode) }
-  def BlockLocalVariableNode(name, location); end
+  sig { params(flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::BlockLocalVariableNode) }
+  def BlockLocalVariableNode(flags, name, location); end
   # Create a new BlockNode node
-  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
+  sig { params(locals: T::Array[Symbol], 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, 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
+  sig { params(flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::BlockParameterNode) }
+  def BlockParameterNode(flags, name, name_loc, operator_loc, location); end
   # Create a new BlockParametersNode node
   sig { params(parameters: T.nilable(Prism::ParametersNode), locals: T::Array[Prism::Node], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::BlockParametersNode) }
   def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location); end
@@ -7391,8 +7453,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], 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
+  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
   # 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
@@ -7523,11 +7585,11 @@ module Prism::DSL
   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
+  sig { params(flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::KeywordRestParameterNode) }
+  def KeywordRestParameterNode(flags, name, name_loc, operator_loc, location); end
   # Create a new LambdaNode node
-  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
+  sig { params(locals: T::Array[Symbol], 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, 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
@@ -7586,11 +7648,11 @@ module Prism::DSL
   sig { params(number: Integer, location: Prism::Location).returns(Prism::NumberedReferenceReadNode) }
   def NumberedReferenceReadNode(number, location); end
   # Create a new OptionalKeywordParameterNode node
-  sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::OptionalKeywordParameterNode) }
-  def OptionalKeywordParameterNode(name, name_loc, value, location); end
+  sig { params(flags: Integer, name: Symbol, name_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::OptionalKeywordParameterNode) }
+  def OptionalKeywordParameterNode(flags, name, name_loc, value, location); end
   # Create a new OptionalParameterNode node
-  sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::OptionalParameterNode) }
-  def OptionalParameterNode(name, name_loc, operator_loc, value, location); end
+  sig { params(flags: Integer, name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::OptionalParameterNode) }
+  def OptionalParameterNode(flags, name, name_loc, operator_loc, value, location); end
   # Create a new OrNode node
   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
@@ -7628,11 +7690,11 @@ module Prism::DSL
   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
+  sig { params(flags: Integer, name: Symbol, name_loc: Prism::Location, location: Prism::Location).returns(Prism::RequiredKeywordParameterNode) }
+  def RequiredKeywordParameterNode(flags, name, name_loc, location); end
   # Create a new RequiredParameterNode node
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::RequiredParameterNode) }
-  def RequiredParameterNode(name, location); end
+  sig { params(flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::RequiredParameterNode) }
+  def RequiredParameterNode(flags, name, location); end
   # Create a new RescueModifierNode node
   sig { params(expression: Prism::Node, keyword_loc: Prism::Location, rescue_expression: Prism::Node, location: Prism::Location).returns(Prism::RescueModifierNode) }
   def RescueModifierNode(expression, keyword_loc, rescue_expression, location); end
@@ -7640,8 +7702,8 @@ module Prism::DSL
   sig { params(keyword_loc: Prism::Location, exceptions: T::Array[Prism::Node], operator_loc: T.nilable(Prism::Location), reference: T.nilable(Prism::Node), statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::RescueNode), location: Prism::Location).returns(Prism::RescueNode) }
   def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end
   # Create a new RestParameterNode node
-  sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::RestParameterNode) }
-  def RestParameterNode(name, name_loc, operator_loc, location); end
+  sig { params(flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, location: Prism::Location).returns(Prism::RestParameterNode) }
+  def RestParameterNode(flags, name, name_loc, operator_loc, location); end
   # Create a new RetryNode node
   sig { params(location: Prism::Location).returns(Prism::RetryNode) }
   def RetryNode(location); end