rbi/prism.rbi in prism-0.18.0 vs rbi/prism.rbi in prism-0.19.0

- old
+ new

@@ -163,19 +163,19 @@ # Represents a set of arguments to a method or a keyword. # # 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end @@ -188,11 +188,11 @@ 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 keyword_splat?; end + def contains_keyword_splat?; end sig { params(inspector: Prism::NodeInspector).returns(String) } def inspect(inspector); end end @@ -200,21 +200,24 @@ # a special array using % like %w or %i. # # [1, 2, 3] # ^^^^^^^^^ class Prism::ArrayNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(T::Array[Prism::Node]) } def elements; end sig { returns(T.nilable(Prism::Location)) } def opening_loc; end 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -227,10 +230,13 @@ 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 contains_splat?; end + sig { returns(T.nilable(String)) } def opening; end sig { returns(T.nilable(String)) } def closing; end @@ -534,11 +540,14 @@ # ^^^^^^^^^^^^^^ 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)) } def body; end @@ -546,12 +555,12 @@ def opening_loc; end 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -704,22 +713,22 @@ # Represents the use of the `&&=` operator on a call. # # foo.bar &&= value # ^^^^^^^^^^^^^^^^^ class Prism::CallAndWriteNode < 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(T.nilable(Prism::Location)) } def message_loc; end - sig { returns(Integer) } - def flags; end - sig { returns(Symbol) } def read_name; end sig { returns(Symbol) } def write_name; end @@ -728,12 +737,12 @@ 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), 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -746,22 +755,25 @@ 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.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 sig { params(inspector: Prism::NodeInspector).returns(String) } def inspect(inspector); end @@ -785,16 +797,22 @@ # ^^^^^^^ # # 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 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end @@ -806,19 +824,13 @@ def closing_loc; end sig { returns(T.nilable(Prism::Node)) } def block; end - sig { returns(Integer) } - def flags; 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 { 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(visitor: Prism::Visitor).void } def accept(visitor); end sig { returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end @@ -830,10 +842,19 @@ 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(T.nilable(String)) } def call_operator; end sig { returns(T.nilable(String)) } def message; end @@ -842,37 +863,31 @@ def opening; end 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 # Represents the use of an assignment operator on a call. # # foo.bar += baz # ^^^^^^^^^^^^^^ class Prism::CallOperatorWriteNode < 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(T.nilable(Prism::Location)) } def message_loc; end - sig { returns(Integer) } - def flags; end - sig { returns(Symbol) } def read_name; end sig { returns(Symbol) } def write_name; end @@ -884,12 +899,12 @@ 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), 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -902,43 +917,46 @@ 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.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 # Represents the use of the `||=` operator on a call. # # foo.bar ||= value # ^^^^^^^^^^^^^^^^^ class Prism::CallOrWriteNode < 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(T.nilable(Prism::Location)) } def message_loc; end - sig { returns(Integer) } - def flags; end - sig { returns(Symbol) } def read_name; end sig { returns(Symbol) } def write_name; end @@ -947,12 +965,12 @@ 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), 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -965,25 +983,93 @@ 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(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 end # Represents assigning to a local variable in pattern matching. @@ -1903,10 +1989,13 @@ def body; end 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 sig { returns(T.nilable(Prism::Location)) } def operator_loc; end @@ -1921,12 +2010,12 @@ def equal_loc; end 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -2264,25 +2353,25 @@ # Represents the use of the `..` or `...` operators to create flip flops. # # baz if foo .. bar # ^^^^^^^^^^ class Prism::FlipFlopNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(T.nilable(Prism::Node)) } def left; end sig { returns(T.nilable(Prism::Node)) } def right; end sig { returns(Prism::Location) } def operator_loc; end - sig { returns(Integer) } - def flags; 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(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(visitor: Prism::Visitor).void } def accept(visitor); end sig { returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end @@ -2294,16 +2383,16 @@ 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 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 # Represents a floating point number literal. @@ -2922,10 +3011,46 @@ sig { params(inspector: Prism::NodeInspector).returns(String) } 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 # ^^^^^^^^^^^ class Prism::InNode < Prism::Node @@ -2972,10 +3097,13 @@ # Represents the use of the `&&=` operator on a call to the `[]` method. # # foo.bar[baz] &&= value # ^^^^^^^^^^^^^^^^^^^^^^ class Prism::IndexAndWriteNode < 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 @@ -2990,21 +3118,18 @@ def closing_loc; end 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -3017,25 +3142,28 @@ 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(T.nilable(String)) } def call_operator; end sig { returns(String) } def opening; end 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 sig { params(inspector: Prism::NodeInspector).returns(String) } def inspect(inspector); end @@ -3044,10 +3172,13 @@ # Represents the use of an assignment operator on a call to `[]`. # # foo.bar[baz] += value # ^^^^^^^^^^^^^^^^^^^^^ class Prism::IndexOperatorWriteNode < 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 @@ -3062,24 +3193,21 @@ def closing_loc; end sig { returns(T.nilable(Prism::Node)) } def block; end - sig { returns(Integer) } - def flags; end - sig { returns(Symbol) } def operator; 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: 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -3092,34 +3220,40 @@ 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(T.nilable(String)) } def call_operator; end sig { returns(String) } def opening; end 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 # Represents the use of the `||=` operator on a call to `[]`. # # foo.bar[baz] ||= value # ^^^^^^^^^^^^^^^^^^^^^^ class Prism::IndexOrWriteNode < 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 @@ -3134,21 +3268,18 @@ def closing_loc; end 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -3161,28 +3292,99 @@ 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(T.nilable(String)) } def call_operator; end sig { returns(String) } def opening; end sig { returns(String) } def closing; end + sig { returns(String) } + def operator; end + + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end + +# Represents assigning to an index. +# +# foo[bar], = 1 +# ^^^^^^^^ +# +# begin +# rescue => foo[bar] +# ^^^^^^^^ +# end +# +# for foo[bar] in baz do end +# ^^^^^^^^ +class Prism::IndexTargetNode < Prism::Node + sig { returns(Integer) } + def flags; end + + sig { returns(Prism::Node) } + def receiver; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def block; end + + sig { params(flags: Integer, receiver: Prism::Node, opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), location: Prism::Location).void } + def initialize(flags, receiver, opening_loc, arguments, closing_loc, block, location); end + + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(Prism::IndexTargetNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) } + def deconstruct_keys(keys); end + sig { returns(T::Boolean) } def safe_navigation?; end sig { returns(T::Boolean) } def variable_call?; end + sig { returns(T::Boolean) } + def attribute_write?; end + sig { returns(String) } - def operator; end + def opening; end + sig { returns(String) } + def closing; end + sig { params(inspector: Prism::NodeInspector).returns(String) } def inspect(inspector); end end # Represents the use of the `&&=` operator for assignment to an instance variable. @@ -3441,14 +3643,14 @@ sig { returns(T::Boolean) } 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 sig { params(inspector: Prism::NodeInspector).returns(String) } @@ -3460,25 +3662,25 @@ # against the last line read by an IO object. # # 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 sig { returns(T::Array[Prism::Node]) } def parts; end sig { returns(Prism::Location) } def closing_loc; end - sig { returns(Integer) } - def flags; 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(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(visitor: Prism::Visitor).void } def accept(visitor); end def set_newline_flag(newline_marked); end @@ -3492,16 +3694,10 @@ 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 opening; end - - sig { returns(String) } - def closing; end - sig { returns(T::Boolean) } def ignore_case?; end sig { returns(T::Boolean) } def extended?; end @@ -3522,34 +3718,49 @@ def windows_31j?; end 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 # Represents a regular expression literal that contains interpolation. # # /foo #{bar} baz/ # ^^^^^^^^^^^^^^^^ class Prism::InterpolatedRegularExpressionNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(Prism::Location) } def opening_loc; end sig { returns(T::Array[Prism::Node]) } def parts; end sig { returns(Prism::Location) } def closing_loc; end - sig { returns(Integer) } - def flags; 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(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(visitor: Prism::Visitor).void } def accept(visitor); end def set_newline_flag(newline_marked); end @@ -3563,16 +3774,10 @@ 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 opening; end - - sig { returns(String) } - def closing; end - sig { returns(T::Boolean) } def ignore_case?; end sig { returns(T::Boolean) } def extended?; end @@ -3593,10 +3798,25 @@ def windows_31j?; end 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 # Represents a string literal that contains interpolation. @@ -3734,15 +3954,18 @@ # Represents a hash literal without opening and closing braces. # # 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -3755,10 +3978,13 @@ 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 static_keys?; end + sig { params(inspector: Prism::NodeInspector).returns(String) } def inspect(inspector); end end # Represents a keyword rest parameter to a method, block, or lambda definition. @@ -3807,27 +4033,30 @@ # ^^^^^^^^^^^^^^^^^^^^^^^ 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 sig { returns(Prism::Location) } def opening_loc; end 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -4108,10 +4337,13 @@ # object. # # if /foo/i then end # ^^^^^^ class Prism::MatchLastLineNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(Prism::Location) } def opening_loc; end sig { returns(Prism::Location) } def content_loc; end @@ -4120,16 +4352,13 @@ def closing_loc; end sig { returns(String) } def unescaped; end - sig { returns(Integer) } - def flags; 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(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(visitor: Prism::Visitor).void } def accept(visitor); end sig { returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end @@ -4141,19 +4370,10 @@ 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 opening; end - - sig { returns(String) } - def content; end - - sig { returns(String) } - def closing; end - sig { returns(T::Boolean) } def ignore_case?; end sig { returns(T::Boolean) } def extended?; end @@ -4174,10 +4394,28 @@ def windows_31j?; end 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 # Represents the use of the modifier `in` operator. @@ -4574,10 +4812,41 @@ sig { params(inspector: Prism::NodeInspector).returns(String) } 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 # ^^ class Prism::NumberedReferenceReadNode < Prism::Node @@ -4735,11 +5004,11 @@ def requireds; end 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]) } def posts; end @@ -4750,11 +5019,11 @@ def keyword_rest; end 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 } def accept(visitor); end @@ -5036,25 +5305,25 @@ # ^^^^ # # 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 sig { returns(T.nilable(Prism::Node)) } def right; end sig { returns(Prism::Location) } def operator_loc; end - sig { returns(Integer) } - def flags; 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(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(visitor: Prism::Visitor).void } def accept(visitor); end sig { returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end @@ -5066,16 +5335,16 @@ 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 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 # Represents a rational number literal. @@ -5138,10 +5407,13 @@ # Represents a regular expression literal with no interpolation. # # /foo/i # ^^^^^^ class Prism::RegularExpressionNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(Prism::Location) } def opening_loc; end sig { returns(Prism::Location) } def content_loc; end @@ -5150,16 +5422,13 @@ def closing_loc; end sig { returns(String) } def unescaped; end - sig { returns(Integer) } - def flags; 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(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(visitor: Prism::Visitor).void } def accept(visitor); end sig { returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end @@ -5171,19 +5440,10 @@ 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 opening; end - - sig { returns(String) } - def content; end - - sig { returns(String) } - def closing; end - sig { returns(T::Boolean) } def ignore_case?; end sig { returns(T::Boolean) } def extended?; end @@ -5204,10 +5464,28 @@ def windows_31j?; end 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 # Represents a required keyword parameter to a method, block, or lambda definition. @@ -5751,10 +6029,16 @@ 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 sig { returns(T.nilable(String)) } def opening; end @@ -5828,10 +6112,13 @@ # ^^^^ # # %i[foo] # ^^^ class Prism::SymbolNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(T.nilable(Prism::Location)) } def opening_loc; end sig { returns(T.nilable(Prism::Location)) } def value_loc; end @@ -5840,12 +6127,12 @@ def closing_loc; end 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -5858,10 +6145,19 @@ 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 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 sig { returns(T.nilable(String)) } def value; end @@ -6001,10 +6297,13 @@ # ^^^^^^^^^^^^^ # # until foo do bar end # ^^^^^^^^^^^^^^^^^^^^ class Prism::UntilNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(Prism::Location) } def keyword_loc; end sig { returns(T.nilable(Prism::Location)) } def closing_loc; end @@ -6013,16 +6312,13 @@ def predicate; end sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end - sig { returns(Integer) } - def flags; 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(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(visitor: Prism::Visitor).void } def accept(visitor); end def set_newline_flag(newline_marked); end @@ -6036,19 +6332,19 @@ 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 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 # Represents the use of the `when` keyword within a case statement. @@ -6098,10 +6394,13 @@ # ^^^^^^^^^^^^^ # # while foo do bar end # ^^^^^^^^^^^^^^^^^^^^ class Prism::WhileNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(Prism::Location) } def keyword_loc; end sig { returns(T.nilable(Prism::Location)) } def closing_loc; end @@ -6110,16 +6409,13 @@ def predicate; end sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end - sig { returns(Integer) } - def flags; 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(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(visitor: Prism::Visitor).void } def accept(visitor); end def set_newline_flag(newline_marked); end @@ -6133,28 +6429,31 @@ 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 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 # Represents an xstring literal with no interpolation. # # `foo` # ^^^^^ class Prism::XStringNode < Prism::Node + sig { returns(Integer) } + def flags; end + sig { returns(Prism::Location) } def opening_loc; end sig { returns(Prism::Location) } def content_loc; end @@ -6163,12 +6462,12 @@ def closing_loc; end 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 sig { returns(T::Array[T.nilable(Prism::Node)]) } @@ -6181,10 +6480,16 @@ 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 forced_utf8_encoding?; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + sig { returns(String) } def opening; end sig { returns(String) } def content; end @@ -6246,33 +6551,55 @@ # 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. module Prism::CallNodeFlags # &. operator 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 BEGIN_MODIFIER = T.let(1 << 0, Integer) end @@ -6299,19 +6626,39 @@ ASCII_8BIT = T.let(1 << 5, Integer) # s - forces the Windows-31J encoding 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 + class Prism::Visitor < Prism::BasicVisitor # Visit a AliasGlobalVariableNode node sig { params(node: Prism::AliasGlobalVariableNode).void } def visit_alias_global_variable_node(node); end @@ -6393,10 +6740,14 @@ # Visit a CallOrWriteNode node 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 @@ -6581,10 +6932,14 @@ # Visit a ImplicitNode node 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 # Visit a IndexAndWriteNode node @@ -6597,10 +6952,14 @@ # Visit a IndexOrWriteNode node 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 # Visit a InstanceVariableOperatorWriteNode node @@ -6725,10 +7084,14 @@ # Visit a NoKeywordsParameterNode node 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 # Visit a OptionalKeywordParameterNode node @@ -6906,15 +7269,15 @@ def AlternationPatternNode(left, right, operator_loc, location); end # Create a new AndNode node 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 # 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) } @@ -6933,33 +7296,36 @@ 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 # 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 # 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 # Create a new BreakNode node 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) } @@ -7023,12 +7389,12 @@ def ConstantTargetNode(name, location); end # Create a new ConstantWriteNode node 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 # Create a new ElseNode node sig { params(else_keyword_loc: Prism::Location, statements: T.nilable(Prism::StatementsNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::ElseNode) } @@ -7047,12 +7413,12 @@ def FalseNode(location); end # Create a new FindPatternNode node 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 # Create a new ForNode node sig { params(index: Prism::Node, collection: Prism::Node, statements: T.nilable(Prism::StatementsNode), for_keyword_loc: Prism::Location, in_keyword_loc: Prism::Location, do_keyword_loc: T.nilable(Prism::Location), end_keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::ForNode) } @@ -7097,22 +7463,28 @@ 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 # Create a new InstanceVariableOperatorWriteNode node sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::InstanceVariableOperatorWriteNode) } @@ -7131,33 +7503,33 @@ def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location); end # Create a new IntegerNode node 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 # Create a new InterpolatedSymbolNode 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::InterpolatedSymbolNode) } def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location); end # Create a new InterpolatedXStringNode node 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 # Create a new LocalVariableOperatorWriteNode node sig { params(name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, name: Symbol, operator: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableOperatorWriteNode) } @@ -7173,12 +7545,12 @@ def LocalVariableTargetNode(name, depth, location); end # Create a new LocalVariableWriteNode node 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 # Create a new MatchRequiredNode node sig { params(value: Prism::Node, pattern: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::MatchRequiredNode) } @@ -7205,10 +7577,13 @@ sig { params(location: Prism::Location).returns(Prism::NilNode) } def NilNode(location); end # 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 # Create a new OptionalKeywordParameterNode node sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::OptionalKeywordParameterNode) } @@ -7218,11 +7593,11 @@ def OptionalParameterNode(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 # 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) } def ParenthesesNode(body, opening_loc, closing_loc, location); end # Create a new PinnedExpressionNode node @@ -7239,21 +7614,21 @@ def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location); end # Create a new ProgramNode node 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 # Create a new RedoNode node 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 # Create a new RequiredParameterNode node sig { params(name: Symbol, location: Prism::Location).returns(Prism::RequiredParameterNode) } @@ -7299,32 +7674,32 @@ def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location); end # Create a new SuperNode node 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 # Create a new UndefNode node 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, 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 end