rbi/prism.rbi in prism-0.17.0 vs rbi/prism.rbi in prism-0.17.1

- old
+ new

@@ -1,7305 +1,7301 @@ -# typed: true - =begin This file is generated by the templates/template.rb script and should not be modified manually. See templates/rbi/prism.rbi.erb if you are looking to modify the template =end -module Prism - # Represents the use of the `alias` keyword to alias a global variable. - # - # alias $foo $bar - # ^^^^^^^^^^^^^^^ - class AliasGlobalVariableNode < Node - sig { returns(Node) } - attr_reader :new_name +# Represents the use of the `alias` keyword to alias a global variable. +# +# alias $foo $bar +# ^^^^^^^^^^^^^^^ +class Prism::AliasGlobalVariableNode < Prism::Node + sig { returns(Prism::Node) } + def new_name; end - sig { returns(Node) } - attr_reader :old_name + sig { returns(Prism::Node) } + def old_name; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { params(new_name: Node, old_name: Node, keyword_loc: Location, location: Location).void } - def initialize(new_name, old_name, keyword_loc, location); end + sig { params(new_name: Prism::Node, old_name: Prism::Node, keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(new_name, old_name, keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(AliasGlobalVariableNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::AliasGlobalVariableNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `alias` keyword to alias a method. - # - # alias foo bar - # ^^^^^^^^^^^^^ - class AliasMethodNode < Node - sig { returns(Node) } - attr_reader :new_name +# Represents the use of the `alias` keyword to alias a method. +# +# alias foo bar +# ^^^^^^^^^^^^^ +class Prism::AliasMethodNode < Prism::Node + sig { returns(Prism::Node) } + def new_name; end - sig { returns(Node) } - attr_reader :old_name + sig { returns(Prism::Node) } + def old_name; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { params(new_name: Node, old_name: Node, keyword_loc: Location, location: Location).void } - def initialize(new_name, old_name, keyword_loc, location); end + sig { params(new_name: Prism::Node, old_name: Prism::Node, keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(new_name, old_name, keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(AliasMethodNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::AliasMethodNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an alternation pattern in pattern matching. - # - # foo => bar | baz - # ^^^^^^^^^ - class AlternationPatternNode < Node - sig { returns(Node) } - attr_reader :left +# Represents an alternation pattern in pattern matching. +# +# foo => bar | baz +# ^^^^^^^^^ +class Prism::AlternationPatternNode < Prism::Node + sig { returns(Prism::Node) } + def left; end - sig { returns(Node) } - attr_reader :right + sig { returns(Prism::Node) } + def right; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(left: Node, right: Node, operator_loc: Location, location: Location).void } - def initialize(left, right, operator_loc, location); end + sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(left, right, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(AlternationPatternNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::AlternationPatternNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `&&` operator or the `and` keyword. - # - # left and right - # ^^^^^^^^^^^^^^ - class AndNode < Node - sig { returns(Node) } - attr_reader :left +# Represents the use of the `&&` operator or the `and` keyword. +# +# left and right +# ^^^^^^^^^^^^^^ +class Prism::AndNode < Prism::Node + sig { returns(Prism::Node) } + def left; end - sig { returns(Node) } - attr_reader :right + sig { returns(Prism::Node) } + def right; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(left: Node, right: Node, operator_loc: Location, location: Location).void } - def initialize(left, right, operator_loc, location); end + sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(left, right, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(AndNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::AndNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a set of arguments to a method or a keyword. - # - # return foo, bar, baz - # ^^^^^^^^^^^^^ - class ArgumentsNode < Node - sig { returns(T::Array[Node]) } - attr_reader :arguments +# 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) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(arguments: T::Array[Node], flags: Integer, location: Location).void } - def initialize(arguments, flags, location); end + sig { params(arguments: T::Array[Prism::Node], flags: Integer, location: Prism::Location).void } + def initialize(arguments, flags, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ArgumentsNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ArgumentsNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword_splat?; end + sig { returns(T::Boolean) } + def keyword_splat?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + 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. - # - # [1, 2, 3] - # ^^^^^^^^^ - class ArrayNode < Node - sig { returns(T::Array[Node]) } - attr_reader :elements +# Represents an array literal. This can be a regular array using brackets or +# a special array using % like %w or %i. +# +# [1, 2, 3] +# ^^^^^^^^^ +class Prism::ArrayNode < Prism::Node + sig { returns(T::Array[Prism::Node]) } + def elements; end - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { params(elements: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } - def initialize(elements, opening_loc, closing_loc, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ArrayNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ArrayNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an array pattern in pattern matching. - # - # foo in 1, 2 - # ^^^^^^^^^^^ - # - # foo in [1, 2] - # ^^^^^^^^^^^^^ - # - # foo in *1 - # ^^^^^^^^^ - # - # foo in Bar[] - # ^^^^^^^^^^^^ - # - # foo in Bar[1, 2, 3] - # ^^^^^^^^^^^^^^^^^^^ - class ArrayPatternNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :constant +# Represents an array pattern in pattern matching. +# +# foo in 1, 2 +# ^^^^^^^^^^^ +# +# foo in [1, 2] +# ^^^^^^^^^^^^^ +# +# foo in *1 +# ^^^^^^^^^ +# +# foo in Bar[] +# ^^^^^^^^^^^^ +# +# foo in Bar[1, 2, 3] +# ^^^^^^^^^^^^^^^^^^^ +class Prism::ArrayPatternNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def constant; end - sig { returns(T::Array[Node]) } - attr_reader :requireds + sig { returns(T::Array[Prism::Node]) } + def requireds; end - sig { returns(T.nilable(Node)) } - attr_reader :rest + sig { returns(T.nilable(Prism::Node)) } + def rest; end - sig { returns(T::Array[Node]) } - attr_reader :posts + sig { returns(T::Array[Prism::Node]) } + def posts; end - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { params(constant: T.nilable(Node), requireds: T::Array[Node], rest: T.nilable(Node), posts: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } - def initialize(constant, requireds, rest, posts, opening_loc, closing_loc, location); end + 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).void } + def initialize(constant, requireds, rest, posts, opening_loc, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ArrayPatternNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ArrayPatternNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a hash key/value pair. - # - # { a => b } - # ^^^^^^ - class AssocNode < Node - sig { returns(Node) } - attr_reader :key +# Represents a hash key/value pair. +# +# { a => b } +# ^^^^^^ +class Prism::AssocNode < Prism::Node + sig { returns(Prism::Node) } + def key; end - sig { returns(T.nilable(Node)) } - attr_reader :value + sig { returns(T.nilable(Prism::Node)) } + def value; end - sig { returns(T.nilable(Location)) } - attr_reader :operator_loc + sig { returns(T.nilable(Prism::Location)) } + def operator_loc; end - sig { params(key: Node, value: T.nilable(Node), operator_loc: T.nilable(Location), location: Location).void } - def initialize(key, value, operator_loc, location); end + sig { params(key: Prism::Node, value: T.nilable(Prism::Node), operator_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(key, value, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(AssocNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::AssocNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 operator; end + sig { returns(T.nilable(String)) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a splat in a hash literal. - # - # { **foo } - # ^^^^^ - class AssocSplatNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :value +# Represents a splat in a hash literal. +# +# { **foo } +# ^^^^^ +class Prism::AssocSplatNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def value; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(value: T.nilable(Node), operator_loc: Location, location: Location).void } - def initialize(value, operator_loc, location); end + sig { params(value: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(value, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(AssocSplatNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::AssocSplatNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents reading a reference to a field in the previous match. - # - # $' - # ^^ - class BackReferenceReadNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents reading a reference to a field in the previous match. +# +# $' +# ^^ +class Prism::BackReferenceReadNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(BackReferenceReadNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::BackReferenceReadNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a begin statement. - # - # begin - # foo - # end - # ^^^^^ - class BeginNode < Node - sig { returns(T.nilable(Location)) } - attr_reader :begin_keyword_loc +# Represents a begin statement. +# +# begin +# foo +# end +# ^^^^^ +class Prism::BeginNode < Prism::Node + sig { returns(T.nilable(Prism::Location)) } + def begin_keyword_loc; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(T.nilable(RescueNode)) } - attr_reader :rescue_clause + sig { returns(T.nilable(Prism::RescueNode)) } + def rescue_clause; end - sig { returns(T.nilable(ElseNode)) } - attr_reader :else_clause + sig { returns(T.nilable(Prism::ElseNode)) } + def else_clause; end - sig { returns(T.nilable(EnsureNode)) } - attr_reader :ensure_clause + sig { returns(T.nilable(Prism::EnsureNode)) } + def ensure_clause; end - sig { returns(T.nilable(Location)) } - attr_reader :end_keyword_loc + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end - sig { params(begin_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), rescue_clause: T.nilable(RescueNode), else_clause: T.nilable(ElseNode), ensure_clause: T.nilable(EnsureNode), end_keyword_loc: T.nilable(Location), location: Location).void } - def initialize(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end + sig { params(begin_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), rescue_clause: T.nilable(Prism::RescueNode), else_clause: T.nilable(Prism::ElseNode), ensure_clause: T.nilable(Prism::EnsureNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(BeginNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::BeginNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 begin_keyword; end + sig { returns(T.nilable(String)) } + def begin_keyword; end - sig { returns(T.nilable(String)) } - def end_keyword; end + sig { returns(T.nilable(String)) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents block method arguments. - # - # bar(&args) - # ^^^^^^^^^^ - class BlockArgumentNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :expression +# Represents block method arguments. +# +# bar(&args) +# ^^^^^^^^^^ +class Prism::BlockArgumentNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def expression; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(expression: T.nilable(Node), operator_loc: Location, location: Location).void } - def initialize(expression, operator_loc, location); end + sig { params(expression: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(expression, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(BlockArgumentNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::BlockArgumentNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a block local variable. - # - # a { |; b| } - # ^ - class BlockLocalVariableNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents a block local variable. +# +# a { |; b| } +# ^ +class Prism::BlockLocalVariableNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(BlockLocalVariableNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::BlockLocalVariableNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - 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 } - # ^^^^^^^^^^^^^^ - class BlockNode < Node - sig { returns(T::Array[Symbol]) } - attr_reader :locals +# Represents a block of ruby code. +# +# [1, 2, 3].each { |i| puts x } +# ^^^^^^^^^^^^^^ +class Prism::BlockNode < Prism::Node + sig { returns(T::Array[Symbol]) } + def locals; end - sig { returns(T.nilable(BlockParametersNode)) } - attr_reader :parameters + sig { returns(T.nilable(Prism::BlockParametersNode)) } + def parameters; end - sig { returns(T.nilable(Node)) } - attr_reader :body + sig { returns(T.nilable(Prism::Node)) } + def body; end - sig { returns(Location) } - attr_reader :opening_loc + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { params(locals: T::Array[Symbol], parameters: T.nilable(BlockParametersNode), body: T.nilable(Node), opening_loc: Location, closing_loc: Location, location: Location).void } - def initialize(locals, parameters, body, opening_loc, closing_loc, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(BlockNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::BlockNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a block parameter to a method, block, or lambda definition. - # - # def a(&b) - # ^^ - # end - class BlockParameterNode < Node - sig { returns(T.nilable(Symbol)) } - attr_reader :name +# Represents a block parameter to a method, block, or lambda definition. +# +# def a(&b) +# ^^ +# end +class Prism::BlockParameterNode < Prism::Node + sig { returns(T.nilable(Symbol)) } + def name; end - sig { returns(T.nilable(Location)) } - attr_reader :name_loc + sig { returns(T.nilable(Prism::Location)) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location, location: Location).void } - def initialize(name, name_loc, operator_loc, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(BlockParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::BlockParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a block's parameters declaration. - # - # -> (a, b = 1; local) { } - # ^^^^^^^^^^^^^^^^^ - # - # foo do |a, b = 1; local| - # ^^^^^^^^^^^^^^^^^ - # end - class BlockParametersNode < Node - sig { returns(T.nilable(ParametersNode)) } - attr_reader :parameters +# Represents a block's parameters declaration. +# +# -> (a, b = 1; local) { } +# ^^^^^^^^^^^^^^^^^ +# +# foo do |a, b = 1; local| +# ^^^^^^^^^^^^^^^^^ +# end +class Prism::BlockParametersNode < Prism::Node + sig { returns(T.nilable(Prism::ParametersNode)) } + def parameters; end - sig { returns(T::Array[Node]) } - attr_reader :locals + sig { returns(T::Array[Prism::Node]) } + def locals; end - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { params(parameters: T.nilable(ParametersNode), locals: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } - def initialize(parameters, locals, opening_loc, closing_loc, location); end + 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).void } + def initialize(parameters, locals, opening_loc, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(BlockParametersNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::BlockParametersNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `break` keyword. - # - # break foo - # ^^^^^^^^^ - class BreakNode < Node - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments +# Represents the use of the `break` keyword. +# +# break foo +# ^^^^^^^^^ +class Prism::BreakNode < Prism::Node + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { params(arguments: T.nilable(ArgumentsNode), keyword_loc: Location, location: Location).void } - def initialize(arguments, keyword_loc, location); end + sig { params(arguments: T.nilable(Prism::ArgumentsNode), keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(arguments, keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(BreakNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::BreakNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - 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 CallAndWriteNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :receiver +# Represents the use of the `&&=` operator on a call. +# +# foo.bar &&= value +# ^^^^^^^^^^^^^^^^^ +class Prism::CallAndWriteNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def receiver; end - sig { returns(T.nilable(Location)) } - attr_reader :call_operator_loc + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :message_loc + sig { returns(T.nilable(Prism::Location)) } + def message_loc; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { returns(Symbol) } - attr_reader :read_name + sig { returns(Symbol) } + def read_name; end - sig { returns(Symbol) } - attr_reader :write_name + sig { returns(Symbol) } + def write_name; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location).void } - def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(CallAndWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::CallAndWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 call_operator; end - sig { returns(T.nilable(String)) } - def message; end + sig { returns(T.nilable(String)) } + def message; end - sig { returns(T::Boolean) } - def safe_navigation?; end + sig { returns(T::Boolean) } + def safe_navigation?; end - sig { returns(T::Boolean) } - def variable_call?; end + sig { returns(T::Boolean) } + def variable_call?; end - sig { returns(String) } - def operator; end + sig { returns(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a method call, in all of the various forms that can take. - # - # foo - # ^^^ - # - # foo() - # ^^^^^ - # - # +foo - # ^^^^ - # - # foo + bar - # ^^^^^^^^^ - # - # foo.bar - # ^^^^^^^ - # - # foo&.bar - # ^^^^^^^^ - class CallNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :receiver +# Represents a method call, in all of the various forms that can take. +# +# foo +# ^^^ +# +# foo() +# ^^^^^ +# +# +foo +# ^^^^ +# +# foo + bar +# ^^^^^^^^^ +# +# foo.bar +# ^^^^^^^ +# +# foo&.bar +# ^^^^^^^^ +class Prism::CallNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def receiver; end - sig { returns(T.nilable(Location)) } - attr_reader :call_operator_loc + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :message_loc + sig { returns(T.nilable(Prism::Location)) } + def message_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :block + sig { returns(T.nilable(Prism::Node)) } + def block; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { returns(Symbol) } - attr_reader :name + sig { returns(Symbol) } + def name; end - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), block: T.nilable(Node), flags: Integer, name: Symbol, location: Location).void } - def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location); 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(CallNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::CallNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 call_operator; end - sig { returns(T.nilable(String)) } - def message; end + sig { returns(T.nilable(String)) } + def message; end - sig { returns(T.nilable(String)) } - def opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { returns(T::Boolean) } - def safe_navigation?; end + sig { returns(T::Boolean) } + def safe_navigation?; end - sig { returns(T::Boolean) } - def variable_call?; end + sig { returns(T::Boolean) } + def variable_call?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - 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 CallOperatorWriteNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :receiver +# Represents the use of an assignment operator on a call. +# +# foo.bar += baz +# ^^^^^^^^^^^^^^ +class Prism::CallOperatorWriteNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def receiver; end - sig { returns(T.nilable(Location)) } - attr_reader :call_operator_loc + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :message_loc + sig { returns(T.nilable(Prism::Location)) } + def message_loc; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { returns(Symbol) } - attr_reader :read_name + sig { returns(Symbol) } + def read_name; end - sig { returns(Symbol) } - attr_reader :write_name + sig { returns(Symbol) } + def write_name; end - sig { returns(Symbol) } - attr_reader :operator + sig { returns(Symbol) } + def operator; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location).void } - def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(CallOperatorWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::CallOperatorWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 call_operator; end - sig { returns(T.nilable(String)) } - def message; end + sig { returns(T.nilable(String)) } + def message; end - sig { returns(T::Boolean) } - def safe_navigation?; end + sig { returns(T::Boolean) } + def safe_navigation?; end - sig { returns(T::Boolean) } - def variable_call?; end + sig { returns(T::Boolean) } + def variable_call?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - 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 CallOrWriteNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :receiver +# Represents the use of the `||=` operator on a call. +# +# foo.bar ||= value +# ^^^^^^^^^^^^^^^^^ +class Prism::CallOrWriteNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def receiver; end - sig { returns(T.nilable(Location)) } - attr_reader :call_operator_loc + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :message_loc + sig { returns(T.nilable(Prism::Location)) } + def message_loc; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { returns(Symbol) } - attr_reader :read_name + sig { returns(Symbol) } + def read_name; end - sig { returns(Symbol) } - attr_reader :write_name + sig { returns(Symbol) } + def write_name; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location).void } - def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(CallOrWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::CallOrWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 call_operator; end - sig { returns(T.nilable(String)) } - def message; end + sig { returns(T.nilable(String)) } + def message; end - sig { returns(T::Boolean) } - def safe_navigation?; end + sig { returns(T::Boolean) } + def safe_navigation?; end - sig { returns(T::Boolean) } - def variable_call?; end + sig { returns(T::Boolean) } + def variable_call?; end - sig { returns(String) } - def operator; end + sig { returns(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents assigning to a local variable in pattern matching. - # - # foo => [bar => baz] - # ^^^^^^^^^^^^ - class CapturePatternNode < Node - sig { returns(Node) } - attr_reader :value +# Represents assigning to a local variable in pattern matching. +# +# foo => [bar => baz] +# ^^^^^^^^^^^^ +class Prism::CapturePatternNode < Prism::Node + sig { returns(Prism::Node) } + def value; end - sig { returns(Node) } - attr_reader :target + sig { returns(Prism::Node) } + def target; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(value: Node, target: Node, operator_loc: Location, location: Location).void } - def initialize(value, target, operator_loc, location); end + sig { params(value: Prism::Node, target: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(value, target, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(CapturePatternNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::CapturePatternNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of a case statement. - # - # case true - # when false - # end - # ^^^^^^^^^^ - class CaseNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :predicate +# Represents the use of a case statement. +# +# case true +# when false +# end +# ^^^^^^^^^^ +class Prism::CaseNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def predicate; end - sig { returns(T::Array[Node]) } - attr_reader :conditions + sig { returns(T::Array[Prism::Node]) } + def conditions; end - sig { returns(T.nilable(ElseNode)) } - attr_reader :consequent + sig { returns(T.nilable(Prism::ElseNode)) } + def consequent; end - sig { returns(Location) } - attr_reader :case_keyword_loc + sig { returns(Prism::Location) } + def case_keyword_loc; end - sig { returns(Location) } - attr_reader :end_keyword_loc + sig { returns(Prism::Location) } + def end_keyword_loc; end - sig { params(predicate: T.nilable(Node), conditions: T::Array[Node], consequent: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location, location: Location).void } - def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end + sig { params(predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::Node], consequent: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(CaseNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::CaseNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); end + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) } + def deconstruct_keys(keys); end - sig { returns(String) } - def case_keyword; end + sig { returns(String) } + def case_keyword; end - sig { returns(String) } - def end_keyword; end + sig { returns(String) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a class declaration involving the `class` keyword. - # - # class Foo end - # ^^^^^^^^^^^^^ - class ClassNode < Node - sig { returns(T::Array[Symbol]) } - attr_reader :locals +# Represents a class declaration involving the `class` keyword. +# +# class Foo end +# ^^^^^^^^^^^^^ +class Prism::ClassNode < Prism::Node + sig { returns(T::Array[Symbol]) } + def locals; end - sig { returns(Location) } - attr_reader :class_keyword_loc + sig { returns(Prism::Location) } + def class_keyword_loc; end - sig { returns(Node) } - attr_reader :constant_path + sig { returns(Prism::Node) } + def constant_path; end - sig { returns(T.nilable(Location)) } - attr_reader :inheritance_operator_loc + sig { returns(T.nilable(Prism::Location)) } + def inheritance_operator_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :superclass + sig { returns(T.nilable(Prism::Node)) } + def superclass; end - sig { returns(T.nilable(Node)) } - attr_reader :body + sig { returns(T.nilable(Prism::Node)) } + def body; end - sig { returns(Location) } - attr_reader :end_keyword_loc + sig { returns(Prism::Location) } + def end_keyword_loc; end - sig { returns(Symbol) } - attr_reader :name + sig { returns(Symbol) } + def name; end - sig { params(locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: T.nilable(Location), superclass: T.nilable(Node), body: T.nilable(Node), end_keyword_loc: Location, name: Symbol, location: Location).void } - def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end + sig { params(locals: T::Array[Symbol], class_keyword_loc: Prism::Location, constant_path: Prism::Node, inheritance_operator_loc: T.nilable(Prism::Location), superclass: T.nilable(Prism::Node), body: T.nilable(Prism::Node), end_keyword_loc: Prism::Location, name: Symbol, location: Prism::Location).void } + def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ClassNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ClassNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 class_keyword; end + sig { returns(String) } + def class_keyword; end - sig { returns(T.nilable(String)) } - def inheritance_operator; end + sig { returns(T.nilable(String)) } + def inheritance_operator; end - sig { returns(String) } - def end_keyword; end + sig { returns(String) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `&&=` operator for assignment to a class variable. - # - # @@target &&= value - # ^^^^^^^^^^^^^^^^^^ - class ClassVariableAndWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents the use of the `&&=` operator for assignment to a class variable. +# +# @@target &&= value +# ^^^^^^^^^^^^^^^^^^ +class Prism::ClassVariableAndWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ClassVariableAndWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ClassVariableAndWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents assigning to a class variable using an operator that isn't `=`. - # - # @@target += value - # ^^^^^^^^^^^^^^^^^ - class ClassVariableOperatorWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents assigning to a class variable using an operator that isn't `=`. +# +# @@target += value +# ^^^^^^^^^^^^^^^^^ +class Prism::ClassVariableOperatorWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Symbol) } - attr_reader :operator + sig { returns(Symbol) } + def operator; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } - def initialize(name, name_loc, operator_loc, value, operator, location); end + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void } + def initialize(name, name_loc, operator_loc, value, operator, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ClassVariableOperatorWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ClassVariableOperatorWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `||=` operator for assignment to a class variable. - # - # @@target ||= value - # ^^^^^^^^^^^^^^^^^^ - class ClassVariableOrWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents the use of the `||=` operator for assignment to a class variable. +# +# @@target ||= value +# ^^^^^^^^^^^^^^^^^^ +class Prism::ClassVariableOrWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ClassVariableOrWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ClassVariableOrWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents referencing a class variable. - # - # @@foo - # ^^^^^ - class ClassVariableReadNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents referencing a class variable. +# +# @@foo +# ^^^^^ +class Prism::ClassVariableReadNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ClassVariableReadNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ClassVariableReadNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a class variable in a context that doesn't have an explicit value. - # - # @@foo, @@bar = baz - # ^^^^^ ^^^^^ - class ClassVariableTargetNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to a class variable in a context that doesn't have an explicit value. +# +# @@foo, @@bar = baz +# ^^^^^ ^^^^^ +class Prism::ClassVariableTargetNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ClassVariableTargetNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ClassVariableTargetNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a class variable. - # - # @@foo = 1 - # ^^^^^^^^^ - class ClassVariableWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to a class variable. +# +# @@foo = 1 +# ^^^^^^^^^ +class Prism::ClassVariableWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(T.nilable(Location)) } - attr_reader :operator_loc + sig { returns(T.nilable(Prism::Location)) } + def operator_loc; end - sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: T.nilable(Location), location: Location).void } - def initialize(name, name_loc, value, operator_loc, location); end + sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, operator_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(name, name_loc, value, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ClassVariableWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ClassVariableWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 operator; end + sig { returns(T.nilable(String)) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `&&=` operator for assignment to a constant. - # - # Target &&= value - # ^^^^^^^^^^^^^^^^ - class ConstantAndWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents the use of the `&&=` operator for assignment to a constant. +# +# Target &&= value +# ^^^^^^^^^^^^^^^^ +class Prism::ConstantAndWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantAndWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantAndWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents assigning to a constant using an operator that isn't `=`. - # - # Target += value - # ^^^^^^^^^^^^^^^ - class ConstantOperatorWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents assigning to a constant using an operator that isn't `=`. +# +# Target += value +# ^^^^^^^^^^^^^^^ +class Prism::ConstantOperatorWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Symbol) } - attr_reader :operator + sig { returns(Symbol) } + def operator; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } - def initialize(name, name_loc, operator_loc, value, operator, location); end + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void } + def initialize(name, name_loc, operator_loc, value, operator, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantOperatorWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantOperatorWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `||=` operator for assignment to a constant. - # - # Target ||= value - # ^^^^^^^^^^^^^^^^ - class ConstantOrWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents the use of the `||=` operator for assignment to a constant. +# +# Target ||= value +# ^^^^^^^^^^^^^^^^ +class Prism::ConstantOrWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantOrWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantOrWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `&&=` operator for assignment to a constant path. - # - # Parent::Child &&= value - # ^^^^^^^^^^^^^^^^^^^^^^^ - class ConstantPathAndWriteNode < Node - sig { returns(ConstantPathNode) } - attr_reader :target +# Represents the use of the `&&=` operator for assignment to a constant path. +# +# Parent::Child &&= value +# ^^^^^^^^^^^^^^^^^^^^^^^ +class Prism::ConstantPathAndWriteNode < Prism::Node + sig { returns(Prism::ConstantPathNode) } + def target; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).void } - def initialize(target, operator_loc, value, location); end + sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void } + def initialize(target, operator_loc, value, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantPathAndWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantPathAndWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents accessing a constant through a path of `::` operators. - # - # Foo::Bar - # ^^^^^^^^ - class ConstantPathNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :parent +# Represents accessing a constant through a path of `::` operators. +# +# Foo::Bar +# ^^^^^^^^ +class Prism::ConstantPathNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def parent; end - sig { returns(Node) } - attr_reader :child + sig { returns(Prism::Node) } + def child; end - sig { returns(Location) } - attr_reader :delimiter_loc + sig { returns(Prism::Location) } + def delimiter_loc; end - sig { params(parent: T.nilable(Node), child: Node, delimiter_loc: Location, location: Location).void } - def initialize(parent, child, delimiter_loc, location); end + sig { params(parent: T.nilable(Prism::Node), child: Prism::Node, delimiter_loc: Prism::Location, location: Prism::Location).void } + def initialize(parent, child, delimiter_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantPathNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantPathNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 delimiter; end + sig { returns(String) } + def delimiter; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents assigning to a constant path using an operator that isn't `=`. - # - # Parent::Child += value - # ^^^^^^^^^^^^^^^^^^^^^^ - class ConstantPathOperatorWriteNode < Node - sig { returns(ConstantPathNode) } - attr_reader :target +# Represents assigning to a constant path using an operator that isn't `=`. +# +# Parent::Child += value +# ^^^^^^^^^^^^^^^^^^^^^^ +class Prism::ConstantPathOperatorWriteNode < Prism::Node + sig { returns(Prism::ConstantPathNode) } + def target; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Symbol) } - attr_reader :operator + sig { returns(Symbol) } + def operator; end - sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } - def initialize(target, operator_loc, value, operator, location); end + sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void } + def initialize(target, operator_loc, value, operator, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantPathOperatorWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantPathOperatorWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `||=` operator for assignment to a constant path. - # - # Parent::Child ||= value - # ^^^^^^^^^^^^^^^^^^^^^^^ - class ConstantPathOrWriteNode < Node - sig { returns(ConstantPathNode) } - attr_reader :target +# Represents the use of the `||=` operator for assignment to a constant path. +# +# Parent::Child ||= value +# ^^^^^^^^^^^^^^^^^^^^^^^ +class Prism::ConstantPathOrWriteNode < Prism::Node + sig { returns(Prism::ConstantPathNode) } + def target; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).void } - def initialize(target, operator_loc, value, location); end + sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void } + def initialize(target, operator_loc, value, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantPathOrWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantPathOrWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a constant path in a context that doesn't have an explicit value. - # - # Foo::Foo, Bar::Bar = baz - # ^^^^^^^^ ^^^^^^^^ - class ConstantPathTargetNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :parent +# Represents writing to a constant path in a context that doesn't have an explicit value. +# +# Foo::Foo, Bar::Bar = baz +# ^^^^^^^^ ^^^^^^^^ +class Prism::ConstantPathTargetNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def parent; end - sig { returns(Node) } - attr_reader :child + sig { returns(Prism::Node) } + def child; end - sig { returns(Location) } - attr_reader :delimiter_loc + sig { returns(Prism::Location) } + def delimiter_loc; end - sig { params(parent: T.nilable(Node), child: Node, delimiter_loc: Location, location: Location).void } - def initialize(parent, child, delimiter_loc, location); end + sig { params(parent: T.nilable(Prism::Node), child: Prism::Node, delimiter_loc: Prism::Location, location: Prism::Location).void } + def initialize(parent, child, delimiter_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantPathTargetNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantPathTargetNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 delimiter; end + sig { returns(String) } + def delimiter; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a constant path. - # - # ::Foo = 1 - # ^^^^^^^^^ - # - # Foo::Bar = 1 - # ^^^^^^^^^^^^ - # - # ::Foo::Bar = 1 - # ^^^^^^^^^^^^^^ - class ConstantPathWriteNode < Node - sig { returns(ConstantPathNode) } - attr_reader :target +# Represents writing to a constant path. +# +# ::Foo = 1 +# ^^^^^^^^^ +# +# Foo::Bar = 1 +# ^^^^^^^^^^^^ +# +# ::Foo::Bar = 1 +# ^^^^^^^^^^^^^^ +class Prism::ConstantPathWriteNode < Prism::Node + sig { returns(Prism::ConstantPathNode) } + def target; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).void } - def initialize(target, operator_loc, value, location); end + sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void } + def initialize(target, operator_loc, value, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantPathWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantPathWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents referencing a constant. - # - # Foo - # ^^^ - class ConstantReadNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents referencing a constant. +# +# Foo +# ^^^ +class Prism::ConstantReadNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantReadNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantReadNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a constant in a context that doesn't have an explicit value. - # - # Foo, Bar = baz - # ^^^ ^^^ - class ConstantTargetNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to a constant in a context that doesn't have an explicit value. +# +# Foo, Bar = baz +# ^^^ ^^^ +class Prism::ConstantTargetNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantTargetNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantTargetNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a constant. - # - # Foo = 1 - # ^^^^^^^ - class ConstantWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to a constant. +# +# Foo = 1 +# ^^^^^^^ +class Prism::ConstantWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location).void } - def initialize(name, name_loc, value, operator_loc, location); end + sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(name, name_loc, value, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ConstantWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ConstantWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a method definition. - # - # def method - # end - # ^^^^^^^^^^ - class DefNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents a method definition. +# +# def method +# end +# ^^^^^^^^^^ +class Prism::DefNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :receiver + sig { returns(T.nilable(Prism::Node)) } + def receiver; end - sig { returns(T.nilable(ParametersNode)) } - attr_reader :parameters + sig { returns(T.nilable(Prism::ParametersNode)) } + def parameters; end - sig { returns(T.nilable(Node)) } - attr_reader :body + sig { returns(T.nilable(Prism::Node)) } + def body; end - sig { returns(T::Array[Symbol]) } - attr_reader :locals + sig { returns(T::Array[Symbol]) } + def locals; end - sig { returns(Location) } - attr_reader :def_keyword_loc + sig { returns(Prism::Location) } + def def_keyword_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :operator_loc + sig { returns(T.nilable(Prism::Location)) } + def operator_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :lparen_loc + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :rparen_loc + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :equal_loc + sig { returns(T.nilable(Prism::Location)) } + def equal_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :end_keyword_loc + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end - sig { params(name: Symbol, name_loc: Location, receiver: T.nilable(Node), parameters: T.nilable(ParametersNode), body: T.nilable(Node), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: T.nilable(Location), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), equal_loc: T.nilable(Location), end_keyword_loc: T.nilable(Location), location: Location).void } - def initialize(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(DefNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::DefNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 def_keyword; end + sig { returns(String) } + def def_keyword; end - sig { returns(T.nilable(String)) } - def operator; end + sig { returns(T.nilable(String)) } + def operator; end - sig { returns(T.nilable(String)) } - def lparen; end + sig { returns(T.nilable(String)) } + def lparen; end - sig { returns(T.nilable(String)) } - def rparen; end + sig { returns(T.nilable(String)) } + def rparen; end - sig { returns(T.nilable(String)) } - def equal; end + sig { returns(T.nilable(String)) } + def equal; end - sig { returns(T.nilable(String)) } - def end_keyword; end + sig { returns(T.nilable(String)) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `defined?` keyword. - # - # defined?(a) - # ^^^^^^^^^^^ - class DefinedNode < Node - sig { returns(T.nilable(Location)) } - attr_reader :lparen_loc +# Represents the use of the `defined?` keyword. +# +# defined?(a) +# ^^^^^^^^^^^ +class Prism::DefinedNode < Prism::Node + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(T.nilable(Location)) } - attr_reader :rparen_loc + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { params(lparen_loc: T.nilable(Location), value: Node, rparen_loc: T.nilable(Location), keyword_loc: Location, location: Location).void } - def initialize(lparen_loc, value, rparen_loc, keyword_loc, location); end + sig { params(lparen_loc: T.nilable(Prism::Location), value: Prism::Node, rparen_loc: T.nilable(Prism::Location), keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(lparen_loc, value, rparen_loc, keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(DefinedNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::DefinedNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 lparen; end + sig { returns(T.nilable(String)) } + def lparen; end - sig { returns(T.nilable(String)) } - def rparen; end + sig { returns(T.nilable(String)) } + def rparen; end - sig { returns(String) } - def keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an `else` clause in a `case`, `if`, or `unless` statement. - # - # if a then b else c end - # ^^^^^^^^^^ - class ElseNode < Node - sig { returns(Location) } - attr_reader :else_keyword_loc +# Represents an `else` clause in a `case`, `if`, or `unless` statement. +# +# if a then b else c end +# ^^^^^^^^^^ +class Prism::ElseNode < Prism::Node + sig { returns(Prism::Location) } + def else_keyword_loc; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(T.nilable(Location)) } - attr_reader :end_keyword_loc + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end - sig { params(else_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: T.nilable(Location), location: Location).void } - def initialize(else_keyword_loc, statements, end_keyword_loc, location); end + sig { params(else_keyword_loc: Prism::Location, statements: T.nilable(Prism::StatementsNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(else_keyword_loc, statements, end_keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ElseNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ElseNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 else_keyword; end + sig { returns(String) } + def else_keyword; end - sig { returns(T.nilable(String)) } - def end_keyword; end + sig { returns(T.nilable(String)) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an interpolated set of statements. - # - # "foo #{bar}" - # ^^^^^^ - class EmbeddedStatementsNode < Node - sig { returns(Location) } - attr_reader :opening_loc +# Represents an interpolated set of statements. +# +# "foo #{bar}" +# ^^^^^^ +class Prism::EmbeddedStatementsNode < Prism::Node + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { params(opening_loc: Location, statements: T.nilable(StatementsNode), closing_loc: Location, location: Location).void } - def initialize(opening_loc, statements, closing_loc, location); end + sig { params(opening_loc: Prism::Location, statements: T.nilable(Prism::StatementsNode), closing_loc: Prism::Location, location: Prism::Location).void } + def initialize(opening_loc, statements, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(EmbeddedStatementsNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::EmbeddedStatementsNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an interpolated variable. - # - # "foo #@bar" - # ^^^^^ - class EmbeddedVariableNode < Node - sig { returns(Location) } - attr_reader :operator_loc +# Represents an interpolated variable. +# +# "foo #@bar" +# ^^^^^ +class Prism::EmbeddedVariableNode < Prism::Node + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :variable + sig { returns(Prism::Node) } + def variable; end - sig { params(operator_loc: Location, variable: Node, location: Location).void } - def initialize(operator_loc, variable, location); end + sig { params(operator_loc: Prism::Location, variable: Prism::Node, location: Prism::Location).void } + def initialize(operator_loc, variable, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(EmbeddedVariableNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::EmbeddedVariableNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an `ensure` clause in a `begin` statement. - # - # begin - # foo - # ensure - # ^^^^^^ - # bar - # end - class EnsureNode < Node - sig { returns(Location) } - attr_reader :ensure_keyword_loc +# Represents an `ensure` clause in a `begin` statement. +# +# begin +# foo +# ensure +# ^^^^^^ +# bar +# end +class Prism::EnsureNode < Prism::Node + sig { returns(Prism::Location) } + def ensure_keyword_loc; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(Location) } - attr_reader :end_keyword_loc + sig { returns(Prism::Location) } + def end_keyword_loc; end - sig { params(ensure_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: Location, location: Location).void } - def initialize(ensure_keyword_loc, statements, end_keyword_loc, location); end + sig { params(ensure_keyword_loc: Prism::Location, statements: T.nilable(Prism::StatementsNode), end_keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(ensure_keyword_loc, statements, end_keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(EnsureNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::EnsureNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 ensure_keyword; end + sig { returns(String) } + def ensure_keyword; end - sig { returns(String) } - def end_keyword; end + sig { returns(String) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the literal `false` keyword. - # - # false - # ^^^^^ - class FalseNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the use of the literal `false` keyword. +# +# false +# ^^^^^ +class Prism::FalseNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(FalseNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::FalseNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a find pattern in pattern matching. - # - # foo in *bar, baz, *qux - # ^^^^^^^^^^^^^^^ - # - # foo in [*bar, baz, *qux] - # ^^^^^^^^^^^^^^^^^ - # - # foo in Foo(*bar, baz, *qux) - # ^^^^^^^^^^^^^^^^^^^^ - class FindPatternNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :constant +# Represents a find pattern in pattern matching. +# +# foo in *bar, baz, *qux +# ^^^^^^^^^^^^^^^ +# +# foo in [*bar, baz, *qux] +# ^^^^^^^^^^^^^^^^^ +# +# foo in Foo(*bar, baz, *qux) +# ^^^^^^^^^^^^^^^^^^^^ +class Prism::FindPatternNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def constant; end - sig { returns(Node) } - attr_reader :left + sig { returns(Prism::Node) } + def left; end - sig { returns(T::Array[Node]) } - attr_reader :requireds + sig { returns(T::Array[Prism::Node]) } + def requireds; end - sig { returns(Node) } - attr_reader :right + sig { returns(Prism::Node) } + def right; end - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { params(constant: T.nilable(Node), left: Node, requireds: T::Array[Node], right: Node, opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } - def initialize(constant, left, requireds, right, opening_loc, closing_loc, location); end + 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).void } + def initialize(constant, left, requireds, right, opening_loc, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(FindPatternNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::FindPatternNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `..` or `...` operators to create flip flops. - # - # baz if foo .. bar - # ^^^^^^^^^^ - class FlipFlopNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :left +# Represents the use of the `..` or `...` operators to create flip flops. +# +# baz if foo .. bar +# ^^^^^^^^^^ +class Prism::FlipFlopNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def left; end - sig { returns(T.nilable(Node)) } - attr_reader :right + sig { returns(T.nilable(Prism::Node)) } + def right; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location, flags: Integer, location: Location).void } - def initialize(left, right, operator_loc, flags, 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(FlipFlopNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::FlipFlopNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { returns(T::Boolean) } - def exclude_end?; end + sig { returns(T::Boolean) } + def exclude_end?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a floating point number literal. - # - # 1.0 - # ^^^ - class FloatNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents a floating point number literal. +# +# 1.0 +# ^^^ +class Prism::FloatNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(FloatNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::FloatNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `for` keyword. - # - # for i in a end - # ^^^^^^^^^^^^^^ - class ForNode < Node - sig { returns(Node) } - attr_reader :index +# Represents the use of the `for` keyword. +# +# for i in a end +# ^^^^^^^^^^^^^^ +class Prism::ForNode < Prism::Node + sig { returns(Prism::Node) } + def index; end - sig { returns(Node) } - attr_reader :collection + sig { returns(Prism::Node) } + def collection; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(Location) } - attr_reader :for_keyword_loc + sig { returns(Prism::Location) } + def for_keyword_loc; end - sig { returns(Location) } - attr_reader :in_keyword_loc + sig { returns(Prism::Location) } + def in_keyword_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :do_keyword_loc + sig { returns(T.nilable(Prism::Location)) } + def do_keyword_loc; end - sig { returns(Location) } - attr_reader :end_keyword_loc + sig { returns(Prism::Location) } + def end_keyword_loc; end - sig { params(index: Node, collection: Node, statements: T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: T.nilable(Location), end_keyword_loc: Location, location: Location).void } - def initialize(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end + 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).void } + def initialize(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ForNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ForNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 for_keyword; end + sig { returns(String) } + def for_keyword; end - sig { returns(String) } - def in_keyword; end + sig { returns(String) } + def in_keyword; end - sig { returns(T.nilable(String)) } - def do_keyword; end + sig { returns(T.nilable(String)) } + def do_keyword; end - sig { returns(String) } - def end_keyword; end + sig { returns(String) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents forwarding all arguments to this method to another method. - # - # def foo(...) - # bar(...) - # ^^^ - # end - class ForwardingArgumentsNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents forwarding all arguments to this method to another method. +# +# def foo(...) +# bar(...) +# ^^^ +# end +class Prism::ForwardingArgumentsNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ForwardingArgumentsNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ForwardingArgumentsNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the forwarding parameter in a method, block, or lambda declaration. - # - # def foo(...) - # ^^^ - # end - class ForwardingParameterNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the use of the forwarding parameter in a method, block, or lambda declaration. +# +# def foo(...) +# ^^^ +# end +class Prism::ForwardingParameterNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ForwardingParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ForwardingParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `super` keyword without parentheses or arguments. - # - # super - # ^^^^^ - class ForwardingSuperNode < Node - sig { returns(T.nilable(BlockNode)) } - attr_reader :block +# Represents the use of the `super` keyword without parentheses or arguments. +# +# super +# ^^^^^ +class Prism::ForwardingSuperNode < Prism::Node + sig { returns(T.nilable(Prism::BlockNode)) } + def block; end - sig { params(block: T.nilable(BlockNode), location: Location).void } - def initialize(block, location); end + sig { params(block: T.nilable(Prism::BlockNode), location: Prism::Location).void } + def initialize(block, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ForwardingSuperNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ForwardingSuperNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `&&=` operator for assignment to a global variable. - # - # $target &&= value - # ^^^^^^^^^^^^^^^^^ - class GlobalVariableAndWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents the use of the `&&=` operator for assignment to a global variable. +# +# $target &&= value +# ^^^^^^^^^^^^^^^^^ +class Prism::GlobalVariableAndWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(GlobalVariableAndWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::GlobalVariableAndWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents assigning to a global variable using an operator that isn't `=`. - # - # $target += value - # ^^^^^^^^^^^^^^^^ - class GlobalVariableOperatorWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents assigning to a global variable using an operator that isn't `=`. +# +# $target += value +# ^^^^^^^^^^^^^^^^ +class Prism::GlobalVariableOperatorWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Symbol) } - attr_reader :operator + sig { returns(Symbol) } + def operator; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } - def initialize(name, name_loc, operator_loc, value, operator, location); end + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void } + def initialize(name, name_loc, operator_loc, value, operator, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(GlobalVariableOperatorWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::GlobalVariableOperatorWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `||=` operator for assignment to a global variable. - # - # $target ||= value - # ^^^^^^^^^^^^^^^^^ - class GlobalVariableOrWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents the use of the `||=` operator for assignment to a global variable. +# +# $target ||= value +# ^^^^^^^^^^^^^^^^^ +class Prism::GlobalVariableOrWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(GlobalVariableOrWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::GlobalVariableOrWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents referencing a global variable. - # - # $foo - # ^^^^ - class GlobalVariableReadNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents referencing a global variable. +# +# $foo +# ^^^^ +class Prism::GlobalVariableReadNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(GlobalVariableReadNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::GlobalVariableReadNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a global variable in a context that doesn't have an explicit value. - # - # $foo, $bar = baz - # ^^^^ ^^^^ - class GlobalVariableTargetNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to a global variable in a context that doesn't have an explicit value. +# +# $foo, $bar = baz +# ^^^^ ^^^^ +class Prism::GlobalVariableTargetNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(GlobalVariableTargetNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::GlobalVariableTargetNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a global variable. - # - # $foo = 1 - # ^^^^^^^^ - class GlobalVariableWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to a global variable. +# +# $foo = 1 +# ^^^^^^^^ +class Prism::GlobalVariableWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location).void } - def initialize(name, name_loc, value, operator_loc, location); end + sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(name, name_loc, value, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(GlobalVariableWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::GlobalVariableWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a hash literal. - # - # { a => b } - # ^^^^^^^^^^ - class HashNode < Node - sig { returns(Location) } - attr_reader :opening_loc +# Represents a hash literal. +# +# { a => b } +# ^^^^^^^^^^ +class Prism::HashNode < Prism::Node + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(T::Array[Node]) } - attr_reader :elements + sig { returns(T::Array[Prism::Node]) } + def elements; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { params(opening_loc: Location, elements: T::Array[Node], closing_loc: Location, location: Location).void } - def initialize(opening_loc, elements, closing_loc, location); end + sig { params(opening_loc: Prism::Location, elements: T::Array[Prism::Node], closing_loc: Prism::Location, location: Prism::Location).void } + def initialize(opening_loc, elements, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(HashNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::HashNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a hash pattern in pattern matching. - # - # foo => { a: 1, b: 2 } - # ^^^^^^^^^^^^^^ - # - # foo => { a: 1, b: 2, **c } - # ^^^^^^^^^^^^^^^^^^^ - class HashPatternNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :constant +# Represents a hash pattern in pattern matching. +# +# foo => { a: 1, b: 2 } +# ^^^^^^^^^^^^^^ +# +# foo => { a: 1, b: 2, **c } +# ^^^^^^^^^^^^^^^^^^^ +class Prism::HashPatternNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def constant; end - sig { returns(T::Array[Node]) } - attr_reader :elements + sig { returns(T::Array[Prism::Node]) } + def elements; end - sig { returns(T.nilable(Node)) } - attr_reader :rest + sig { returns(T.nilable(Prism::Node)) } + def rest; end - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { params(constant: T.nilable(Node), elements: T::Array[Node], rest: T.nilable(Node), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } - def initialize(constant, elements, rest, opening_loc, closing_loc, location); end + sig { params(constant: T.nilable(Prism::Node), elements: T::Array[Prism::Node], rest: T.nilable(Prism::Node), opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(constant, elements, rest, opening_loc, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(HashPatternNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::HashPatternNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `if` keyword, either in the block form or the modifier form. - # - # bar if foo - # ^^^^^^^^^^ - # - # if foo then bar end - # ^^^^^^^^^^^^^^^^^^^ - class IfNode < Node - sig { returns(T.nilable(Location)) } - attr_reader :if_keyword_loc +# Represents the use of the `if` keyword, either in the block form or the modifier form. +# +# bar if foo +# ^^^^^^^^^^ +# +# if foo then bar end +# ^^^^^^^^^^^^^^^^^^^ +class Prism::IfNode < Prism::Node + sig { returns(T.nilable(Prism::Location)) } + def if_keyword_loc; end - sig { returns(Node) } - attr_reader :predicate + sig { returns(Prism::Node) } + def predicate; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(T.nilable(Node)) } - attr_reader :consequent + sig { returns(T.nilable(Prism::Node)) } + def consequent; end - sig { returns(T.nilable(Location)) } - attr_reader :end_keyword_loc + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end - sig { params(if_keyword_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), consequent: T.nilable(Node), end_keyword_loc: T.nilable(Location), location: Location).void } - def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(IfNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::IfNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 if_keyword; end + sig { returns(T.nilable(String)) } + def if_keyword; end - sig { returns(T.nilable(String)) } - def end_keyword; end + sig { returns(T.nilable(String)) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an imaginary number literal. - # - # 1.0i - # ^^^^ - class ImaginaryNode < Node - sig { returns(Node) } - attr_reader :numeric +# Represents an imaginary number literal. +# +# 1.0i +# ^^^^ +class Prism::ImaginaryNode < Prism::Node + sig { returns(Prism::Node) } + def numeric; end - sig { params(numeric: Node, location: Location).void } - def initialize(numeric, location); end + sig { params(numeric: Prism::Node, location: Prism::Location).void } + def initialize(numeric, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ImaginaryNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ImaginaryNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + 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. - # - # { foo: } - # ^^^^ - # - # { Foo: } - # ^^^^ - class ImplicitNode < Node - sig { returns(Node) } - attr_reader :value +# Represents a node that is implicitly being added to the tree but doesn't +# correspond directly to a node in the source. +# +# { foo: } +# ^^^^ +# +# { Foo: } +# ^^^^ +class Prism::ImplicitNode < Prism::Node + sig { returns(Prism::Node) } + def value; end - sig { params(value: Node, location: Location).void } - def initialize(value, location); end + sig { params(value: Prism::Node, location: Prism::Location).void } + def initialize(value, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ImplicitNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ImplicitNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - 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 InNode < Node - sig { returns(Node) } - attr_reader :pattern +# Represents the use of the `in` keyword in a case statement. +# +# case a; in b then c end +# ^^^^^^^^^^^ +class Prism::InNode < Prism::Node + sig { returns(Prism::Node) } + def pattern; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(Location) } - attr_reader :in_loc + sig { returns(Prism::Location) } + def in_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :then_loc + sig { returns(T.nilable(Prism::Location)) } + def then_loc; end - sig { params(pattern: Node, statements: T.nilable(StatementsNode), in_loc: Location, then_loc: T.nilable(Location), location: Location).void } - def initialize(pattern, statements, in_loc, then_loc, location); end + sig { params(pattern: Prism::Node, statements: T.nilable(Prism::StatementsNode), in_loc: Prism::Location, then_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(pattern, statements, in_loc, then_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 in; end + sig { returns(String) } + def in; end - sig { returns(T.nilable(String)) } - def then; end + sig { returns(T.nilable(String)) } + def then; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `&&=` operator on a call to the `[]` method. - # - # foo.bar[baz] &&= value - # ^^^^^^^^^^^^^^^^^^^^^^ - class IndexAndWriteNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :receiver +# Represents the use of the `&&=` operator on a call to the `[]` method. +# +# foo.bar[baz] &&= value +# ^^^^^^^^^^^^^^^^^^^^^^ +class Prism::IndexAndWriteNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def receiver; end - sig { returns(T.nilable(Location)) } - attr_reader :call_operator_loc + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end - sig { returns(Location) } - attr_reader :opening_loc + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :block + sig { returns(T.nilable(Prism::Node)) } + def block; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(Node), flags: Integer, operator_loc: Location, value: Node, location: Location).void } - def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(IndexAndWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::IndexAndWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 call_operator; end - sig { returns(String) } - def opening; end + sig { returns(String) } + def opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { returns(T::Boolean) } - def safe_navigation?; end + sig { returns(T::Boolean) } + def safe_navigation?; end - sig { returns(T::Boolean) } - def variable_call?; end + sig { returns(T::Boolean) } + def variable_call?; end - sig { returns(String) } - def operator; end + sig { returns(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of an assignment operator on a call to `[]`. - # - # foo.bar[baz] += value - # ^^^^^^^^^^^^^^^^^^^^^ - class IndexOperatorWriteNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :receiver +# Represents the use of an assignment operator on a call to `[]`. +# +# foo.bar[baz] += value +# ^^^^^^^^^^^^^^^^^^^^^ +class Prism::IndexOperatorWriteNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def receiver; end - sig { returns(T.nilable(Location)) } - attr_reader :call_operator_loc + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end - sig { returns(Location) } - attr_reader :opening_loc + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :block + sig { returns(T.nilable(Prism::Node)) } + def block; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { returns(Symbol) } - attr_reader :operator + sig { returns(Symbol) } + def operator; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(Node), flags: Integer, operator: Symbol, operator_loc: Location, value: Node, location: Location).void } - def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(IndexOperatorWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::IndexOperatorWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 call_operator; end - sig { returns(String) } - def opening; end + sig { returns(String) } + def opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { returns(T::Boolean) } - def safe_navigation?; end + sig { returns(T::Boolean) } + def safe_navigation?; end - sig { returns(T::Boolean) } - def variable_call?; end + sig { returns(T::Boolean) } + def variable_call?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - 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 IndexOrWriteNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :receiver +# Represents the use of the `||=` operator on a call to `[]`. +# +# foo.bar[baz] ||= value +# ^^^^^^^^^^^^^^^^^^^^^^ +class Prism::IndexOrWriteNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def receiver; end - sig { returns(T.nilable(Location)) } - attr_reader :call_operator_loc + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end - sig { returns(Location) } - attr_reader :opening_loc + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :block + sig { returns(T.nilable(Prism::Node)) } + def block; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(Node), flags: Integer, operator_loc: Location, value: Node, location: Location).void } - def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(IndexOrWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::IndexOrWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 call_operator; end - sig { returns(String) } - def opening; end + sig { returns(String) } + def opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { returns(T::Boolean) } - def safe_navigation?; end + sig { returns(T::Boolean) } + def safe_navigation?; end - sig { returns(T::Boolean) } - def variable_call?; end + sig { returns(T::Boolean) } + def variable_call?; end - sig { returns(String) } - def operator; end + sig { returns(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - 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. - # - # @target &&= value - # ^^^^^^^^^^^^^^^^^ - class InstanceVariableAndWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents the use of the `&&=` operator for assignment to an instance variable. +# +# @target &&= value +# ^^^^^^^^^^^^^^^^^ +class Prism::InstanceVariableAndWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InstanceVariableAndWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InstanceVariableAndWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents assigning to an instance variable using an operator that isn't `=`. - # - # @target += value - # ^^^^^^^^^^^^^^^^ - class InstanceVariableOperatorWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents assigning to an instance variable using an operator that isn't `=`. +# +# @target += value +# ^^^^^^^^^^^^^^^^ +class Prism::InstanceVariableOperatorWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Symbol) } - attr_reader :operator + sig { returns(Symbol) } + def operator; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } - def initialize(name, name_loc, operator_loc, value, operator, location); end + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void } + def initialize(name, name_loc, operator_loc, value, operator, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InstanceVariableOperatorWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InstanceVariableOperatorWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - 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. - # - # @target ||= value - # ^^^^^^^^^^^^^^^^^ - class InstanceVariableOrWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents the use of the `||=` operator for assignment to an instance variable. +# +# @target ||= value +# ^^^^^^^^^^^^^^^^^ +class Prism::InstanceVariableOrWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InstanceVariableOrWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InstanceVariableOrWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents referencing an instance variable. - # - # @foo - # ^^^^ - class InstanceVariableReadNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents referencing an instance variable. +# +# @foo +# ^^^^ +class Prism::InstanceVariableReadNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InstanceVariableReadNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InstanceVariableReadNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to an instance variable in a context that doesn't have an explicit value. - # - # @foo, @bar = baz - # ^^^^ ^^^^ - class InstanceVariableTargetNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to an instance variable in a context that doesn't have an explicit value. +# +# @foo, @bar = baz +# ^^^^ ^^^^ +class Prism::InstanceVariableTargetNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InstanceVariableTargetNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InstanceVariableTargetNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to an instance variable. - # - # @foo = 1 - # ^^^^^^^^ - class InstanceVariableWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to an instance variable. +# +# @foo = 1 +# ^^^^^^^^ +class Prism::InstanceVariableWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location).void } - def initialize(name, name_loc, value, operator_loc, location); end + sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(name, name_loc, value, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InstanceVariableWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InstanceVariableWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an integer number literal. - # - # 1 - # ^ - class IntegerNode < Node - sig { returns(Integer) } - attr_reader :flags +# Represents an integer number literal. +# +# 1 +# ^ +class Prism::IntegerNode < Prism::Node + sig { returns(Integer) } + def flags; end - sig { params(flags: Integer, location: Location).void } - def initialize(flags, location); end + sig { params(flags: Integer, location: Prism::Location).void } + def initialize(flags, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(IntegerNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::IntegerNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 binary?; end + sig { returns(T::Boolean) } + def binary?; end - sig { returns(T::Boolean) } - def octal?; end + sig { returns(T::Boolean) } + def octal?; end - sig { returns(T::Boolean) } - def decimal?; end + sig { returns(T::Boolean) } + def decimal?; end - sig { returns(T::Boolean) } - def hexadecimal?; end + sig { returns(T::Boolean) } + def hexadecimal?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + 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. - # - # if /foo #{bar} baz/ then end - # ^^^^^^^^^^^^^^^^ - class InterpolatedMatchLastLineNode < Node - sig { returns(Location) } - attr_reader :opening_loc +# 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 +# ^^^^^^^^^^^^^^^^ +class Prism::InterpolatedMatchLastLineNode < Prism::Node + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(T::Array[Node]) } - attr_reader :parts + sig { returns(T::Array[Prism::Node]) } + def parts; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, flags: Integer, location: Location).void } - def initialize(opening_loc, parts, closing_loc, flags, 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InterpolatedMatchLastLineNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InterpolatedMatchLastLineNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { returns(T::Boolean) } - def ignore_case?; end + sig { returns(T::Boolean) } + def ignore_case?; end - sig { returns(T::Boolean) } - def extended?; end + sig { returns(T::Boolean) } + def extended?; end - sig { returns(T::Boolean) } - def multi_line?; end + sig { returns(T::Boolean) } + def multi_line?; end - sig { returns(T::Boolean) } - def once?; end + sig { returns(T::Boolean) } + def once?; end - sig { returns(T::Boolean) } - def euc_jp?; end + sig { returns(T::Boolean) } + def euc_jp?; end - sig { returns(T::Boolean) } - def ascii_8bit?; end + sig { returns(T::Boolean) } + def ascii_8bit?; end - sig { returns(T::Boolean) } - def windows_31j?; end + sig { returns(T::Boolean) } + def windows_31j?; end - sig { returns(T::Boolean) } - def utf_8?; end + sig { returns(T::Boolean) } + def utf_8?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - 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 InterpolatedRegularExpressionNode < Node - sig { returns(Location) } - attr_reader :opening_loc +# Represents a regular expression literal that contains interpolation. +# +# /foo #{bar} baz/ +# ^^^^^^^^^^^^^^^^ +class Prism::InterpolatedRegularExpressionNode < Prism::Node + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(T::Array[Node]) } - attr_reader :parts + sig { returns(T::Array[Prism::Node]) } + def parts; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, flags: Integer, location: Location).void } - def initialize(opening_loc, parts, closing_loc, flags, 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InterpolatedRegularExpressionNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InterpolatedRegularExpressionNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { returns(T::Boolean) } - def ignore_case?; end + sig { returns(T::Boolean) } + def ignore_case?; end - sig { returns(T::Boolean) } - def extended?; end + sig { returns(T::Boolean) } + def extended?; end - sig { returns(T::Boolean) } - def multi_line?; end + sig { returns(T::Boolean) } + def multi_line?; end - sig { returns(T::Boolean) } - def once?; end + sig { returns(T::Boolean) } + def once?; end - sig { returns(T::Boolean) } - def euc_jp?; end + sig { returns(T::Boolean) } + def euc_jp?; end - sig { returns(T::Boolean) } - def ascii_8bit?; end + sig { returns(T::Boolean) } + def ascii_8bit?; end - sig { returns(T::Boolean) } - def windows_31j?; end + sig { returns(T::Boolean) } + def windows_31j?; end - sig { returns(T::Boolean) } - def utf_8?; end + sig { returns(T::Boolean) } + def utf_8?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a string literal that contains interpolation. - # - # "foo #{bar} baz" - # ^^^^^^^^^^^^^^^^ - class InterpolatedStringNode < Node - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc +# Represents a string literal that contains interpolation. +# +# "foo #{bar} baz" +# ^^^^^^^^^^^^^^^^ +class Prism::InterpolatedStringNode < Prism::Node + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T::Array[Node]) } - attr_reader :parts + sig { returns(T::Array[Prism::Node]) } + def parts; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { params(opening_loc: T.nilable(Location), parts: T::Array[Node], closing_loc: T.nilable(Location), location: Location).void } - def initialize(opening_loc, parts, closing_loc, location); end + sig { params(opening_loc: T.nilable(Prism::Location), parts: T::Array[Prism::Node], closing_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(opening_loc, parts, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InterpolatedStringNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InterpolatedStringNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a symbol literal that contains interpolation. - # - # :"foo #{bar} baz" - # ^^^^^^^^^^^^^^^^^ - class InterpolatedSymbolNode < Node - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc +# Represents a symbol literal that contains interpolation. +# +# :"foo #{bar} baz" +# ^^^^^^^^^^^^^^^^^ +class Prism::InterpolatedSymbolNode < Prism::Node + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T::Array[Node]) } - attr_reader :parts + sig { returns(T::Array[Prism::Node]) } + def parts; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { params(opening_loc: T.nilable(Location), parts: T::Array[Node], closing_loc: T.nilable(Location), location: Location).void } - def initialize(opening_loc, parts, closing_loc, location); end + sig { params(opening_loc: T.nilable(Prism::Location), parts: T::Array[Prism::Node], closing_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(opening_loc, parts, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InterpolatedSymbolNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InterpolatedSymbolNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an xstring literal that contains interpolation. - # - # `foo #{bar} baz` - # ^^^^^^^^^^^^^^^^ - class InterpolatedXStringNode < Node - sig { returns(Location) } - attr_reader :opening_loc +# Represents an xstring literal that contains interpolation. +# +# `foo #{bar} baz` +# ^^^^^^^^^^^^^^^^ +class Prism::InterpolatedXStringNode < Prism::Node + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(T::Array[Node]) } - attr_reader :parts + sig { returns(T::Array[Prism::Node]) } + def parts; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, location: Location).void } - def initialize(opening_loc, parts, closing_loc, location); end + sig { params(opening_loc: Prism::Location, parts: T::Array[Prism::Node], closing_loc: Prism::Location, location: Prism::Location).void } + def initialize(opening_loc, parts, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(InterpolatedXStringNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::InterpolatedXStringNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a hash literal without opening and closing braces. - # - # foo(a: b) - # ^^^^ - class KeywordHashNode < Node - sig { returns(T::Array[Node]) } - attr_reader :elements +# Represents a hash literal without opening and closing braces. +# +# foo(a: b) +# ^^^^ +class Prism::KeywordHashNode < Prism::Node + sig { returns(T::Array[Prism::Node]) } + def elements; end - sig { params(elements: T::Array[Node], location: Location).void } - def initialize(elements, location); end + sig { params(elements: T::Array[Prism::Node], location: Prism::Location).void } + def initialize(elements, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(KeywordHashNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::KeywordHashNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - 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. - # - # def a(**b) - # ^^^ - # end - class KeywordRestParameterNode < Node - sig { returns(T.nilable(Symbol)) } - attr_reader :name +# Represents a keyword rest parameter to a method, block, or lambda definition. +# +# def a(**b) +# ^^^ +# end +class Prism::KeywordRestParameterNode < Prism::Node + sig { returns(T.nilable(Symbol)) } + def name; end - sig { returns(T.nilable(Location)) } - attr_reader :name_loc + sig { returns(T.nilable(Prism::Location)) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location, location: Location).void } - def initialize(name, name_loc, operator_loc, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(KeywordRestParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::KeywordRestParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents using a lambda literal (not the lambda method call). - # - # ->(value) { value * 2 } - # ^^^^^^^^^^^^^^^^^^^^^^^ - class LambdaNode < Node - sig { returns(T::Array[Symbol]) } - attr_reader :locals +# Represents using a lambda literal (not the lambda method call). +# +# ->(value) { value * 2 } +# ^^^^^^^^^^^^^^^^^^^^^^^ +class Prism::LambdaNode < Prism::Node + sig { returns(T::Array[Symbol]) } + def locals; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Location) } - attr_reader :opening_loc + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(T.nilable(BlockParametersNode)) } - attr_reader :parameters + sig { returns(T.nilable(Prism::BlockParametersNode)) } + def parameters; end - sig { returns(T.nilable(Node)) } - attr_reader :body + sig { returns(T.nilable(Prism::Node)) } + def body; end - sig { params(locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: T.nilable(BlockParametersNode), body: T.nilable(Node), location: Location).void } - def initialize(locals, 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::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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(LambdaNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::LambdaNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { returns(String) } - def opening; end + sig { returns(String) } + def opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `&&=` operator for assignment to a local variable. - # - # target &&= value - # ^^^^^^^^^^^^^^^^ - class LocalVariableAndWriteNode < Node - sig { returns(Location) } - attr_reader :name_loc +# Represents the use of the `&&=` operator for assignment to a local variable. +# +# target &&= value +# ^^^^^^^^^^^^^^^^ +class Prism::LocalVariableAndWriteNode < Prism::Node + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Symbol) } - attr_reader :name + sig { returns(Symbol) } + def name; end - sig { returns(Integer) } - attr_reader :depth + sig { returns(Integer) } + def depth; end - sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location).void } - def initialize(name_loc, operator_loc, value, name, depth, location); end + sig { params(name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, name: Symbol, depth: Integer, location: Prism::Location).void } + def initialize(name_loc, operator_loc, value, name, depth, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(LocalVariableAndWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::LocalVariableAndWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents assigning to a local variable using an operator that isn't `=`. - # - # target += value - # ^^^^^^^^^^^^^^^ - class LocalVariableOperatorWriteNode < Node - sig { returns(Location) } - attr_reader :name_loc +# Represents assigning to a local variable using an operator that isn't `=`. +# +# target += value +# ^^^^^^^^^^^^^^^ +class Prism::LocalVariableOperatorWriteNode < Prism::Node + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Symbol) } - attr_reader :name + sig { returns(Symbol) } + def name; end - sig { returns(Symbol) } - attr_reader :operator + sig { returns(Symbol) } + def operator; end - sig { returns(Integer) } - attr_reader :depth + sig { returns(Integer) } + def depth; end - sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location).void } - def initialize(name_loc, operator_loc, value, name, operator, depth, location); end + sig { params(name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, name: Symbol, operator: Symbol, depth: Integer, location: Prism::Location).void } + def initialize(name_loc, operator_loc, value, name, operator, depth, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(LocalVariableOperatorWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::LocalVariableOperatorWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `||=` operator for assignment to a local variable. - # - # target ||= value - # ^^^^^^^^^^^^^^^^ - class LocalVariableOrWriteNode < Node - sig { returns(Location) } - attr_reader :name_loc +# Represents the use of the `||=` operator for assignment to a local variable. +# +# target ||= value +# ^^^^^^^^^^^^^^^^ +class Prism::LocalVariableOrWriteNode < Prism::Node + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Symbol) } - attr_reader :name + sig { returns(Symbol) } + def name; end - sig { returns(Integer) } - attr_reader :depth + sig { returns(Integer) } + def depth; end - sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location).void } - def initialize(name_loc, operator_loc, value, name, depth, location); end + sig { params(name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, name: Symbol, depth: Integer, location: Prism::Location).void } + def initialize(name_loc, operator_loc, value, name, depth, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(LocalVariableOrWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::LocalVariableOrWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + 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. - # - # foo - # ^^^ - class LocalVariableReadNode < Node - sig { returns(Symbol) } - attr_reader :name +# 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 +# ^^^ +class Prism::LocalVariableReadNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Integer) } - attr_reader :depth + sig { returns(Integer) } + def depth; end - sig { params(name: Symbol, depth: Integer, location: Location).void } - def initialize(name, depth, location); end + sig { params(name: Symbol, depth: Integer, location: Prism::Location).void } + def initialize(name, depth, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(LocalVariableReadNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::LocalVariableReadNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a local variable in a context that doesn't have an explicit value. - # - # foo, bar = baz - # ^^^ ^^^ - class LocalVariableTargetNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to a local variable in a context that doesn't have an explicit value. +# +# foo, bar = baz +# ^^^ ^^^ +class Prism::LocalVariableTargetNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Integer) } - attr_reader :depth + sig { returns(Integer) } + def depth; end - sig { params(name: Symbol, depth: Integer, location: Location).void } - def initialize(name, depth, location); end + sig { params(name: Symbol, depth: Integer, location: Prism::Location).void } + def initialize(name, depth, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(LocalVariableTargetNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::LocalVariableTargetNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing to a local variable. - # - # foo = 1 - # ^^^^^^^ - class LocalVariableWriteNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents writing to a local variable. +# +# foo = 1 +# ^^^^^^^ +class Prism::LocalVariableWriteNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Integer) } - attr_reader :depth + sig { returns(Integer) } + def depth; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location).void } - def initialize(name, depth, name_loc, value, operator_loc, location); end + sig { params(name: Symbol, depth: Integer, name_loc: Prism::Location, value: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(name, depth, name_loc, value, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(LocalVariableWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::LocalVariableWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + 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. - # - # if /foo/i then end - # ^^^^^^ - class MatchLastLineNode < Node - sig { returns(Location) } - attr_reader :opening_loc +# 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 +# ^^^^^^ +class Prism::MatchLastLineNode < Prism::Node + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(Location) } - attr_reader :content_loc + sig { returns(Prism::Location) } + def content_loc; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(String) } - attr_reader :unescaped + sig { returns(String) } + def unescaped; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location).void } - def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location); 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(MatchLastLineNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::MatchLastLineNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def content; end + sig { returns(String) } + def content; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { returns(T::Boolean) } - def ignore_case?; end + sig { returns(T::Boolean) } + def ignore_case?; end - sig { returns(T::Boolean) } - def extended?; end + sig { returns(T::Boolean) } + def extended?; end - sig { returns(T::Boolean) } - def multi_line?; end + sig { returns(T::Boolean) } + def multi_line?; end - sig { returns(T::Boolean) } - def once?; end + sig { returns(T::Boolean) } + def once?; end - sig { returns(T::Boolean) } - def euc_jp?; end + sig { returns(T::Boolean) } + def euc_jp?; end - sig { returns(T::Boolean) } - def ascii_8bit?; end + sig { returns(T::Boolean) } + def ascii_8bit?; end - sig { returns(T::Boolean) } - def windows_31j?; end + sig { returns(T::Boolean) } + def windows_31j?; end - sig { returns(T::Boolean) } - def utf_8?; end + sig { returns(T::Boolean) } + def utf_8?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the modifier `in` operator. - # - # foo in bar - # ^^^^^^^^^^ - class MatchPredicateNode < Node - sig { returns(Node) } - attr_reader :value +# Represents the use of the modifier `in` operator. +# +# foo in bar +# ^^^^^^^^^^ +class Prism::MatchPredicateNode < Prism::Node + sig { returns(Prism::Node) } + def value; end - sig { returns(Node) } - attr_reader :pattern + sig { returns(Prism::Node) } + def pattern; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(value: Node, pattern: Node, operator_loc: Location, location: Location).void } - def initialize(value, pattern, operator_loc, location); end + sig { params(value: Prism::Node, pattern: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(value, pattern, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(MatchPredicateNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::MatchPredicateNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `=>` operator. - # - # foo => bar - # ^^^^^^^^^^ - class MatchRequiredNode < Node - sig { returns(Node) } - attr_reader :value +# Represents the use of the `=>` operator. +# +# foo => bar +# ^^^^^^^^^^ +class Prism::MatchRequiredNode < Prism::Node + sig { returns(Prism::Node) } + def value; end - sig { returns(Node) } - attr_reader :pattern + sig { returns(Prism::Node) } + def pattern; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(value: Node, pattern: Node, operator_loc: Location, location: Location).void } - def initialize(value, pattern, operator_loc, location); end + sig { params(value: Prism::Node, pattern: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(value, pattern, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(MatchRequiredNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::MatchRequiredNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents writing local variables using a regular expression match with - # named capture groups. - # - # /(?<foo>bar)/ =~ baz - # ^^^^^^^^^^^^^^^^^^^^ - class MatchWriteNode < Node - sig { returns(CallNode) } - attr_reader :call +# Represents writing local variables using a regular expression match with +# named capture groups. +# +# /(?<foo>bar)/ =~ baz +# ^^^^^^^^^^^^^^^^^^^^ +class Prism::MatchWriteNode < Prism::Node + sig { returns(Prism::CallNode) } + def call; end - sig { returns(T::Array[Symbol]) } - attr_reader :locals + sig { returns(T::Array[Symbol]) } + def locals; end - sig { params(call: CallNode, locals: T::Array[Symbol], location: Location).void } - def initialize(call, locals, location); end + sig { params(call: Prism::CallNode, locals: T::Array[Symbol], location: Prism::Location).void } + def initialize(call, locals, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(MatchWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::MatchWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a node that is missing from the source and results in a syntax - # error. - class MissingNode < Node - sig { params(location: Location).void } - def initialize(location); end +# 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 - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(MissingNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::MissingNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a module declaration involving the `module` keyword. - # - # module Foo end - # ^^^^^^^^^^^^^^ - class ModuleNode < Node - sig { returns(T::Array[Symbol]) } - attr_reader :locals +# Represents a module declaration involving the `module` keyword. +# +# module Foo end +# ^^^^^^^^^^^^^^ +class Prism::ModuleNode < Prism::Node + sig { returns(T::Array[Symbol]) } + def locals; end - sig { returns(Location) } - attr_reader :module_keyword_loc + sig { returns(Prism::Location) } + def module_keyword_loc; end - sig { returns(Node) } - attr_reader :constant_path + sig { returns(Prism::Node) } + def constant_path; end - sig { returns(T.nilable(Node)) } - attr_reader :body + sig { returns(T.nilable(Prism::Node)) } + def body; end - sig { returns(Location) } - attr_reader :end_keyword_loc + sig { returns(Prism::Location) } + def end_keyword_loc; end - sig { returns(Symbol) } - attr_reader :name + sig { returns(Symbol) } + def name; end - sig { params(locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: T.nilable(Node), end_keyword_loc: Location, name: Symbol, location: Location).void } - def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end + sig { params(locals: T::Array[Symbol], module_keyword_loc: Prism::Location, constant_path: Prism::Node, body: T.nilable(Prism::Node), end_keyword_loc: Prism::Location, name: Symbol, location: Prism::Location).void } + def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ModuleNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ModuleNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 module_keyword; end + sig { returns(String) } + def module_keyword; end - sig { returns(String) } - def end_keyword; end + sig { returns(String) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a multi-target expression. - # - # a, (b, c) = 1, 2, 3 - # ^^^^^^ - class MultiTargetNode < Node - sig { returns(T::Array[Node]) } - attr_reader :lefts +# Represents a multi-target expression. +# +# a, (b, c) = 1, 2, 3 +# ^^^^^^ +class Prism::MultiTargetNode < Prism::Node + sig { returns(T::Array[Prism::Node]) } + def lefts; end - sig { returns(T.nilable(Node)) } - attr_reader :rest + sig { returns(T.nilable(Prism::Node)) } + def rest; end - sig { returns(T::Array[Node]) } - attr_reader :rights + sig { returns(T::Array[Prism::Node]) } + def rights; end - sig { returns(T.nilable(Location)) } - attr_reader :lparen_loc + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :rparen_loc + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end - sig { params(lefts: T::Array[Node], rest: T.nilable(Node), rights: T::Array[Node], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), location: Location).void } - def initialize(lefts, rest, rights, lparen_loc, rparen_loc, location); end + sig { params(lefts: T::Array[Prism::Node], rest: T.nilable(Prism::Node), rights: T::Array[Prism::Node], lparen_loc: T.nilable(Prism::Location), rparen_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(lefts, rest, rights, lparen_loc, rparen_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(MultiTargetNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::MultiTargetNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 lparen; end + sig { returns(T.nilable(String)) } + def lparen; end - sig { returns(T.nilable(String)) } - def rparen; end + sig { returns(T.nilable(String)) } + def rparen; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a write to a multi-target expression. - # - # a, b, c = 1, 2, 3 - # ^^^^^^^^^^^^^^^^^ - class MultiWriteNode < Node - sig { returns(T::Array[Node]) } - attr_reader :lefts +# Represents a write to a multi-target expression. +# +# a, b, c = 1, 2, 3 +# ^^^^^^^^^^^^^^^^^ +class Prism::MultiWriteNode < Prism::Node + sig { returns(T::Array[Prism::Node]) } + def lefts; end - sig { returns(T.nilable(Node)) } - attr_reader :rest + sig { returns(T.nilable(Prism::Node)) } + def rest; end - sig { returns(T::Array[Node]) } - attr_reader :rights + sig { returns(T::Array[Prism::Node]) } + def rights; end - sig { returns(T.nilable(Location)) } - attr_reader :lparen_loc + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :rparen_loc + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(lefts: T::Array[Node], rest: T.nilable(Node), rights: T::Array[Node], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), operator_loc: Location, value: Node, location: Location).void } - def initialize(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end + sig { params(lefts: T::Array[Prism::Node], rest: T.nilable(Prism::Node), rights: T::Array[Prism::Node], lparen_loc: T.nilable(Prism::Location), rparen_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void } + def initialize(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(MultiWriteNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::MultiWriteNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 lparen; end + sig { returns(T.nilable(String)) } + def lparen; end - sig { returns(T.nilable(String)) } - def rparen; end + sig { returns(T.nilable(String)) } + def rparen; end - sig { returns(String) } - def operator; end + sig { returns(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `next` keyword. - # - # next 1 - # ^^^^^^ - class NextNode < Node - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments +# Represents the use of the `next` keyword. +# +# next 1 +# ^^^^^^ +class Prism::NextNode < Prism::Node + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { params(arguments: T.nilable(ArgumentsNode), keyword_loc: Location, location: Location).void } - def initialize(arguments, keyword_loc, location); end + sig { params(arguments: T.nilable(Prism::ArgumentsNode), keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(arguments, keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(NextNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::NextNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `nil` keyword. - # - # nil - # ^^^ - class NilNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the use of the `nil` keyword. +# +# nil +# ^^^ +class Prism::NilNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(NilNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::NilNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of `**nil` inside method arguments. - # - # def a(**nil) - # ^^^^^ - # end - class NoKeywordsParameterNode < Node - sig { returns(Location) } - attr_reader :operator_loc +# Represents the use of `**nil` inside method arguments. +# +# def a(**nil) +# ^^^^^ +# end +class Prism::NoKeywordsParameterNode < Prism::Node + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { params(operator_loc: Location, keyword_loc: Location, location: Location).void } - def initialize(operator_loc, keyword_loc, location); end + sig { params(operator_loc: Prism::Location, keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(operator_loc, keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(NoKeywordsParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::NoKeywordsParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { returns(String) } - def keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - 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 NumberedReferenceReadNode < Node - sig { returns(Integer) } - attr_reader :number +# Represents reading a numbered reference to a capture in the previous match. +# +# $1 +# ^^ +class Prism::NumberedReferenceReadNode < Prism::Node + sig { returns(Integer) } + def number; end - sig { params(number: Integer, location: Location).void } - def initialize(number, location); end + sig { params(number: Integer, location: Prism::Location).void } + def initialize(number, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(NumberedReferenceReadNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::NumberedReferenceReadNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an optional keyword parameter to a method, block, or lambda definition. - # - # def a(b: 1) - # ^^^^ - # end - class OptionalKeywordParameterNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents an optional keyword parameter to a method, block, or lambda definition. +# +# def a(b: 1) +# ^^^^ +# end +class Prism::OptionalKeywordParameterNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(OptionalKeywordParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::OptionalKeywordParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an optional parameter to a method, block, or lambda definition. - # - # def a(b = 1) - # ^^^^^ - # end - class OptionalParameterNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents an optional parameter to a method, block, or lambda definition. +# +# def a(b = 1) +# ^^^^^ +# end +class Prism::OptionalParameterNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :value + sig { returns(Prism::Node) } + def value; end - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } - def initialize(name, name_loc, operator_loc, value, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(OptionalParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::OptionalParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `||` operator or the `or` keyword. - # - # left or right - # ^^^^^^^^^^^^^ - class OrNode < Node - sig { returns(Node) } - attr_reader :left +# Represents the use of the `||` operator or the `or` keyword. +# +# left or right +# ^^^^^^^^^^^^^ +class Prism::OrNode < Prism::Node + sig { returns(Prism::Node) } + def left; end - sig { returns(Node) } - attr_reader :right + sig { returns(Prism::Node) } + def right; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(left: Node, right: Node, operator_loc: Location, location: Location).void } - def initialize(left, right, operator_loc, location); end + sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(left, right, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(OrNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::OrNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the list of parameters on a method, block, or lambda definition. - # - # def a(b, c, d) - # ^^^^^^^ - # end - class ParametersNode < Node - sig { returns(T::Array[Node]) } - attr_reader :requireds +# Represents the list of parameters on a method, block, or lambda definition. +# +# def a(b, c, d) +# ^^^^^^^ +# end +class Prism::ParametersNode < Prism::Node + sig { returns(T::Array[Prism::Node]) } + def requireds; end - sig { returns(T::Array[Node]) } - attr_reader :optionals + sig { returns(T::Array[Prism::Node]) } + def optionals; end - sig { returns(T.nilable(RestParameterNode)) } - attr_reader :rest + sig { returns(T.nilable(Prism::RestParameterNode)) } + def rest; end - sig { returns(T::Array[Node]) } - attr_reader :posts + sig { returns(T::Array[Prism::Node]) } + def posts; end - sig { returns(T::Array[Node]) } - attr_reader :keywords + sig { returns(T::Array[Prism::Node]) } + def keywords; end - sig { returns(T.nilable(Node)) } - attr_reader :keyword_rest + sig { returns(T.nilable(Prism::Node)) } + def keyword_rest; end - sig { returns(T.nilable(BlockParameterNode)) } - attr_reader :block + sig { returns(T.nilable(Prism::BlockParameterNode)) } + def block; end - sig { params(requireds: T::Array[Node], optionals: T::Array[Node], rest: T.nilable(RestParameterNode), posts: T::Array[Node], keywords: T::Array[Node], keyword_rest: T.nilable(Node), block: T.nilable(BlockParameterNode), location: Location).void } - def initialize(requireds, optionals, rest, posts, keywords, keyword_rest, block, location); 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 } + def initialize(requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ParametersNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ParametersNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a parenthesized expression - # - # (10 + 34) - # ^^^^^^^^^ - class ParenthesesNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :body +# Represents a parenthesized expression +# +# (10 + 34) +# ^^^^^^^^^ +class Prism::ParenthesesNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def body; end - sig { returns(Location) } - attr_reader :opening_loc + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { params(body: T.nilable(Node), opening_loc: Location, closing_loc: Location, location: Location).void } - def initialize(body, opening_loc, closing_loc, location); end + sig { params(body: T.nilable(Prism::Node), opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).void } + def initialize(body, opening_loc, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ParenthesesNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ParenthesesNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `^` operator for pinning an expression in a - # pattern matching expression. - # - # foo in ^(bar) - # ^^^^^^ - class PinnedExpressionNode < Node - sig { returns(Node) } - attr_reader :expression +# Represents the use of the `^` operator for pinning an expression in a +# pattern matching expression. +# +# foo in ^(bar) +# ^^^^^^ +class Prism::PinnedExpressionNode < Prism::Node + sig { returns(Prism::Node) } + def expression; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Location) } - attr_reader :lparen_loc + sig { returns(Prism::Location) } + def lparen_loc; end - sig { returns(Location) } - attr_reader :rparen_loc + sig { returns(Prism::Location) } + def rparen_loc; end - sig { params(expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location).void } - def initialize(expression, operator_loc, lparen_loc, rparen_loc, location); end + sig { params(expression: Prism::Node, operator_loc: Prism::Location, lparen_loc: Prism::Location, rparen_loc: Prism::Location, location: Prism::Location).void } + def initialize(expression, operator_loc, lparen_loc, rparen_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(PinnedExpressionNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::PinnedExpressionNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { returns(String) } - def lparen; end + sig { returns(String) } + def lparen; end - sig { returns(String) } - def rparen; end + sig { returns(String) } + def rparen; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `^` operator for pinning a variable in a pattern - # matching expression. - # - # foo in ^bar - # ^^^^ - class PinnedVariableNode < Node - sig { returns(Node) } - attr_reader :variable +# Represents the use of the `^` operator for pinning a variable in a pattern +# matching expression. +# +# foo in ^bar +# ^^^^ +class Prism::PinnedVariableNode < Prism::Node + sig { returns(Prism::Node) } + def variable; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(variable: Node, operator_loc: Location, location: Location).void } - def initialize(variable, operator_loc, location); end + sig { params(variable: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void } + def initialize(variable, operator_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(PinnedVariableNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::PinnedVariableNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `END` keyword. - # - # END { foo } - # ^^^^^^^^^^^ - class PostExecutionNode < Node - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements +# Represents the use of the `END` keyword. +# +# END { foo } +# ^^^^^^^^^^^ +class Prism::PostExecutionNode < Prism::Node + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(Location) } - attr_reader :opening_loc + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { params(statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location).void } - def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end + sig { params(statements: T.nilable(Prism::StatementsNode), keyword_loc: Prism::Location, opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).void } + def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(PostExecutionNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::PostExecutionNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { returns(String) } - def opening; end + sig { returns(String) } + def opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `BEGIN` keyword. - # - # BEGIN { foo } - # ^^^^^^^^^^^^^ - class PreExecutionNode < Node - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements +# Represents the use of the `BEGIN` keyword. +# +# BEGIN { foo } +# ^^^^^^^^^^^^^ +class Prism::PreExecutionNode < Prism::Node + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(Location) } - attr_reader :opening_loc + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { params(statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location).void } - def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end + sig { params(statements: T.nilable(Prism::StatementsNode), keyword_loc: Prism::Location, opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).void } + def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(PreExecutionNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::PreExecutionNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { returns(String) } - def opening; end + sig { returns(String) } + def opening; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # The top level node of any parse tree. - class ProgramNode < Node - sig { returns(T::Array[Symbol]) } - attr_reader :locals +# The top level node of any parse tree. +class Prism::ProgramNode < Prism::Node + sig { returns(T::Array[Symbol]) } + def locals; end - sig { returns(StatementsNode) } - attr_reader :statements + sig { returns(Prism::StatementsNode) } + def statements; end - sig { params(locals: T::Array[Symbol], statements: StatementsNode, location: Location).void } - def initialize(locals, statements, location); end + sig { params(locals: T::Array[Symbol], statements: Prism::StatementsNode, location: Prism::Location).void } + def initialize(locals, statements, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ProgramNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ProgramNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `..` or `...` operators. - # - # 1..2 - # ^^^^ - # - # c if a =~ /left/ ... b =~ /right/ - # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - class RangeNode < Node - sig { returns(T.nilable(Node)) } - attr_reader :left +# Represents the use of the `..` or `...` operators. +# +# 1..2 +# ^^^^ +# +# c if a =~ /left/ ... b =~ /right/ +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +class Prism::RangeNode < Prism::Node + sig { returns(T.nilable(Prism::Node)) } + def left; end - sig { returns(T.nilable(Node)) } - attr_reader :right + sig { returns(T.nilable(Prism::Node)) } + def right; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location, flags: Integer, location: Location).void } - def initialize(left, right, operator_loc, flags, 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RangeNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RangeNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { returns(T::Boolean) } - def exclude_end?; end + sig { returns(T::Boolean) } + def exclude_end?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a rational number literal. - # - # 1.0r - # ^^^^ - class RationalNode < Node - sig { returns(Node) } - attr_reader :numeric +# Represents a rational number literal. +# +# 1.0r +# ^^^^ +class Prism::RationalNode < Prism::Node + sig { returns(Prism::Node) } + def numeric; end - sig { params(numeric: Node, location: Location).void } - def initialize(numeric, location); end + sig { params(numeric: Prism::Node, location: Prism::Location).void } + def initialize(numeric, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RationalNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RationalNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `redo` keyword. - # - # redo - # ^^^^ - class RedoNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the use of the `redo` keyword. +# +# redo +# ^^^^ +class Prism::RedoNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RedoNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RedoNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a regular expression literal with no interpolation. - # - # /foo/i - # ^^^^^^ - class RegularExpressionNode < Node - sig { returns(Location) } - attr_reader :opening_loc +# Represents a regular expression literal with no interpolation. +# +# /foo/i +# ^^^^^^ +class Prism::RegularExpressionNode < Prism::Node + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(Location) } - attr_reader :content_loc + sig { returns(Prism::Location) } + def content_loc; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(String) } - attr_reader :unescaped + sig { returns(String) } + def unescaped; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location).void } - def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location); 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RegularExpressionNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RegularExpressionNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def content; end + sig { returns(String) } + def content; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { returns(T::Boolean) } - def ignore_case?; end + sig { returns(T::Boolean) } + def ignore_case?; end - sig { returns(T::Boolean) } - def extended?; end + sig { returns(T::Boolean) } + def extended?; end - sig { returns(T::Boolean) } - def multi_line?; end + sig { returns(T::Boolean) } + def multi_line?; end - sig { returns(T::Boolean) } - def once?; end + sig { returns(T::Boolean) } + def once?; end - sig { returns(T::Boolean) } - def euc_jp?; end + sig { returns(T::Boolean) } + def euc_jp?; end - sig { returns(T::Boolean) } - def ascii_8bit?; end + sig { returns(T::Boolean) } + def ascii_8bit?; end - sig { returns(T::Boolean) } - def windows_31j?; end + sig { returns(T::Boolean) } + def windows_31j?; end - sig { returns(T::Boolean) } - def utf_8?; end + sig { returns(T::Boolean) } + def utf_8?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - 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. - # - # def a(b: ) - # ^^ - # end - class RequiredKeywordParameterNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents a required keyword parameter to a method, block, or lambda definition. +# +# def a(b: ) +# ^^ +# end +class Prism::RequiredKeywordParameterNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { returns(Location) } - attr_reader :name_loc + sig { returns(Prism::Location) } + def name_loc; end - sig { params(name: Symbol, name_loc: Location, location: Location).void } - def initialize(name, name_loc, location); end + sig { params(name: Symbol, name_loc: Prism::Location, location: Prism::Location).void } + def initialize(name, name_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RequiredKeywordParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RequiredKeywordParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a required parameter to a method, block, or lambda definition. - # - # def a(b) - # ^ - # end - class RequiredParameterNode < Node - sig { returns(Symbol) } - attr_reader :name +# Represents a required parameter to a method, block, or lambda definition. +# +# def a(b) +# ^ +# end +class Prism::RequiredParameterNode < Prism::Node + sig { returns(Symbol) } + def name; end - sig { params(name: Symbol, location: Location).void } - def initialize(name, location); end + sig { params(name: Symbol, location: Prism::Location).void } + def initialize(name, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RequiredParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RequiredParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an expression modified with a rescue. - # - # foo rescue nil - # ^^^^^^^^^^^^^^ - class RescueModifierNode < Node - sig { returns(Node) } - attr_reader :expression +# Represents an expression modified with a rescue. +# +# foo rescue nil +# ^^^^^^^^^^^^^^ +class Prism::RescueModifierNode < Prism::Node + sig { returns(Prism::Node) } + def expression; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(Node) } - attr_reader :rescue_expression + sig { returns(Prism::Node) } + def rescue_expression; end - sig { params(expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location).void } - def initialize(expression, keyword_loc, rescue_expression, location); end + sig { params(expression: Prism::Node, keyword_loc: Prism::Location, rescue_expression: Prism::Node, location: Prism::Location).void } + def initialize(expression, keyword_loc, rescue_expression, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RescueModifierNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RescueModifierNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a rescue statement. - # - # begin - # rescue Foo, *splat, Bar => ex - # foo - # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - # end - # - # `Foo, *splat, Bar` are in the `exceptions` field. - # `ex` is in the `exception` field. - class RescueNode < Node - sig { returns(Location) } - attr_reader :keyword_loc +# Represents a rescue statement. +# +# begin +# rescue Foo, *splat, Bar => ex +# foo +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +# end +# +# `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 - sig { returns(T::Array[Node]) } - attr_reader :exceptions + sig { returns(T::Array[Prism::Node]) } + def exceptions; end - sig { returns(T.nilable(Location)) } - attr_reader :operator_loc + sig { returns(T.nilable(Prism::Location)) } + def operator_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :reference + sig { returns(T.nilable(Prism::Node)) } + def reference; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(T.nilable(RescueNode)) } - attr_reader :consequent + sig { returns(T.nilable(Prism::RescueNode)) } + def consequent; end - sig { params(keyword_loc: Location, exceptions: T::Array[Node], operator_loc: T.nilable(Location), reference: T.nilable(Node), statements: T.nilable(StatementsNode), consequent: T.nilable(RescueNode), location: Location).void } - def initialize(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end + 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).void } + def initialize(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RescueNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RescueNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { returns(T.nilable(String)) } - def operator; end + sig { returns(T.nilable(String)) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a rest parameter to a method, block, or lambda definition. - # - # def a(*b) - # ^^ - # end - class RestParameterNode < Node - sig { returns(T.nilable(Symbol)) } - attr_reader :name +# Represents a rest parameter to a method, block, or lambda definition. +# +# def a(*b) +# ^^ +# end +class Prism::RestParameterNode < Prism::Node + sig { returns(T.nilable(Symbol)) } + def name; end - sig { returns(T.nilable(Location)) } - attr_reader :name_loc + sig { returns(T.nilable(Prism::Location)) } + def name_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location, location: Location).void } - def initialize(name, name_loc, operator_loc, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RestParameterNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RestParameterNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `retry` keyword. - # - # retry - # ^^^^^ - class RetryNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the use of the `retry` keyword. +# +# retry +# ^^^^^ +class Prism::RetryNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(RetryNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::RetryNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `return` keyword. - # - # return 1 - # ^^^^^^^^ - class ReturnNode < Node - sig { returns(Location) } - attr_reader :keyword_loc +# Represents the use of the `return` keyword. +# +# return 1 +# ^^^^^^^^ +class Prism::ReturnNode < Prism::Node + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { params(keyword_loc: Location, arguments: T.nilable(ArgumentsNode), location: Location).void } - def initialize(keyword_loc, arguments, location); end + sig { params(keyword_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), location: Prism::Location).void } + def initialize(keyword_loc, arguments, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(ReturnNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::ReturnNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the `self` keyword. - # - # self - # ^^^^ - class SelfNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the `self` keyword. +# +# self +# ^^^^ +class Prism::SelfNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(SelfNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::SelfNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a singleton class declaration involving the `class` keyword. - # - # class << self end - # ^^^^^^^^^^^^^^^^^ - class SingletonClassNode < Node - sig { returns(T::Array[Symbol]) } - attr_reader :locals +# Represents a singleton class declaration involving the `class` keyword. +# +# class << self end +# ^^^^^^^^^^^^^^^^^ +class Prism::SingletonClassNode < Prism::Node + sig { returns(T::Array[Symbol]) } + def locals; end - sig { returns(Location) } - attr_reader :class_keyword_loc + sig { returns(Prism::Location) } + def class_keyword_loc; end - sig { returns(Location) } - attr_reader :operator_loc + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(Node) } - attr_reader :expression + sig { returns(Prism::Node) } + def expression; end - sig { returns(T.nilable(Node)) } - attr_reader :body + sig { returns(T.nilable(Prism::Node)) } + def body; end - sig { returns(Location) } - attr_reader :end_keyword_loc + sig { returns(Prism::Location) } + def end_keyword_loc; end - sig { params(locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: T.nilable(Node), end_keyword_loc: Location, location: Location).void } - def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end + sig { params(locals: T::Array[Symbol], class_keyword_loc: Prism::Location, operator_loc: Prism::Location, expression: Prism::Node, body: T.nilable(Prism::Node), end_keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(SingletonClassNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::SingletonClassNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 class_keyword; end + sig { returns(String) } + def class_keyword; end - sig { returns(String) } - def operator; end + sig { returns(String) } + def operator; end - sig { returns(String) } - def end_keyword; end + sig { returns(String) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `__ENCODING__` keyword. - # - # __ENCODING__ - # ^^^^^^^^^^^^ - class SourceEncodingNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the use of the `__ENCODING__` keyword. +# +# __ENCODING__ +# ^^^^^^^^^^^^ +class Prism::SourceEncodingNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(SourceEncodingNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::SourceEncodingNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `__FILE__` keyword. - # - # __FILE__ - # ^^^^^^^^ - class SourceFileNode < Node - sig { returns(String) } - attr_reader :filepath +# Represents the use of the `__FILE__` keyword. +# +# __FILE__ +# ^^^^^^^^ +class Prism::SourceFileNode < Prism::Node + sig { returns(String) } + def filepath; end - sig { params(filepath: String, location: Location).void } - def initialize(filepath, location); end + sig { params(filepath: String, location: Prism::Location).void } + def initialize(filepath, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(SourceFileNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::SourceFileNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `__LINE__` keyword. - # - # __LINE__ - # ^^^^^^^^ - class SourceLineNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the use of the `__LINE__` keyword. +# +# __LINE__ +# ^^^^^^^^ +class Prism::SourceLineNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(SourceLineNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::SourceLineNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the splat operator. - # - # [*a] - # ^^ - class SplatNode < Node - sig { returns(Location) } - attr_reader :operator_loc +# Represents the use of the splat operator. +# +# [*a] +# ^^ +class Prism::SplatNode < Prism::Node + sig { returns(Prism::Location) } + def operator_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :expression + sig { returns(T.nilable(Prism::Node)) } + def expression; end - sig { params(operator_loc: Location, expression: T.nilable(Node), location: Location).void } - def initialize(operator_loc, expression, location); end + sig { params(operator_loc: Prism::Location, expression: T.nilable(Prism::Node), location: Prism::Location).void } + def initialize(operator_loc, expression, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(SplatNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::SplatNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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(String) } + def operator; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a set of statements contained within some scope. - # - # foo; bar; baz - # ^^^^^^^^^^^^^ - class StatementsNode < Node - sig { returns(T::Array[Node]) } - attr_reader :body +# Represents a set of statements contained within some scope. +# +# foo; bar; baz +# ^^^^^^^^^^^^^ +class Prism::StatementsNode < Prism::Node + sig { returns(T::Array[Prism::Node]) } + def body; end - sig { params(body: T::Array[Node], location: Location).void } - def initialize(body, location); end + sig { params(body: T::Array[Prism::Node], location: Prism::Location).void } + def initialize(body, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(StatementsNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::StatementsNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of compile-time string concatenation. - # - # "foo" "bar" - # ^^^^^^^^^^^ - class StringConcatNode < Node - sig { returns(Node) } - attr_reader :left +# Represents the use of compile-time string concatenation. +# +# "foo" "bar" +# ^^^^^^^^^^^ +class Prism::StringConcatNode < Prism::Node + sig { returns(Prism::Node) } + def left; end - sig { returns(Node) } - attr_reader :right + sig { returns(Prism::Node) } + def right; end - sig { params(left: Node, right: Node, location: Location).void } - def initialize(left, right, location); end + sig { params(left: Prism::Node, right: Prism::Node, location: Prism::Location).void } + def initialize(left, right, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(StringConcatNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::StringConcatNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a string literal, a string contained within a `%w` list, or - # plain string content within an interpolated string. - # - # "foo" - # ^^^^^ - # - # %w[foo] - # ^^^ - # - # "foo #{bar} baz" - # ^^^^ ^^^^ - class StringNode < Node - sig { returns(Integer) } - attr_reader :flags +# Represents a string literal, a string contained within a `%w` list, or +# plain string content within an interpolated string. +# +# "foo" +# ^^^^^ +# +# %w[foo] +# ^^^ +# +# "foo #{bar} baz" +# ^^^^ ^^^^ +class Prism::StringNode < Prism::Node + sig { returns(Integer) } + def flags; end - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(Location) } - attr_reader :content_loc + sig { returns(Prism::Location) } + def content_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { returns(String) } - attr_reader :unescaped + sig { returns(String) } + def unescaped; end - sig { params(flags: Integer, opening_loc: T.nilable(Location), content_loc: Location, closing_loc: T.nilable(Location), unescaped: String, location: Location).void } - def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end + sig { params(flags: Integer, opening_loc: T.nilable(Prism::Location), content_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), unescaped: String, location: Prism::Location).void } + def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(StringNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::StringNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 frozen?; end + sig { returns(T::Boolean) } + def frozen?; end - sig { returns(T.nilable(String)) } - def opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(String) } - def content; end + sig { returns(String) } + def content; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `super` keyword with parentheses or arguments. - # - # super() - # ^^^^^^^ - # - # super foo, bar - # ^^^^^^^^^^^^^^ - class SuperNode < Node - sig { returns(Location) } - attr_reader :keyword_loc +# Represents the use of the `super` keyword with parentheses or arguments. +# +# super() +# ^^^^^^^ +# +# super foo, bar +# ^^^^^^^^^^^^^^ +class Prism::SuperNode < Prism::Node + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :lparen_loc + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { returns(T.nilable(Location)) } - attr_reader :rparen_loc + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end - sig { returns(T.nilable(Node)) } - attr_reader :block + sig { returns(T.nilable(Prism::Node)) } + def block; end - sig { params(keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), block: T.nilable(Node), location: Location).void } - def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end + 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).void } + def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(SuperNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::SuperNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { returns(T.nilable(String)) } - def lparen; end + sig { returns(T.nilable(String)) } + def lparen; end - sig { returns(T.nilable(String)) } - def rparen; end + sig { returns(T.nilable(String)) } + def rparen; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents a symbol literal or a symbol contained within a `%i` list. - # - # :foo - # ^^^^ - # - # %i[foo] - # ^^^ - class SymbolNode < Node - sig { returns(T.nilable(Location)) } - attr_reader :opening_loc +# Represents a symbol literal or a symbol contained within a `%i` list. +# +# :foo +# ^^^^ +# +# %i[foo] +# ^^^ +class Prism::SymbolNode < Prism::Node + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :value_loc + sig { returns(T.nilable(Prism::Location)) } + def value_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { returns(String) } - attr_reader :unescaped + sig { returns(String) } + def unescaped; end - sig { params(opening_loc: T.nilable(Location), value_loc: T.nilable(Location), closing_loc: T.nilable(Location), unescaped: String, location: Location).void } - def initialize(opening_loc, value_loc, closing_loc, unescaped, location); 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(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(SymbolNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::SymbolNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end + sig { returns(T.nilable(String)) } + def opening; end - sig { returns(T.nilable(String)) } - def value; end + sig { returns(T.nilable(String)) } + def value; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the literal `true` keyword. - # - # true - # ^^^^ - class TrueNode < Node - sig { params(location: Location).void } - def initialize(location); end +# Represents the use of the literal `true` keyword. +# +# true +# ^^^^ +class Prism::TrueNode < Prism::Node + sig { params(location: Prism::Location).void } + def initialize(location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(TrueNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::TrueNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `undef` keyword. - # - # undef :foo, :bar, :baz - # ^^^^^^^^^^^^^^^^^^^^^^ - class UndefNode < Node - sig { returns(T::Array[Node]) } - attr_reader :names +# Represents the use of the `undef` keyword. +# +# undef :foo, :bar, :baz +# ^^^^^^^^^^^^^^^^^^^^^^ +class Prism::UndefNode < Prism::Node + sig { returns(T::Array[Prism::Node]) } + def names; end - sig { returns(Location) } - attr_reader :keyword_loc + sig { returns(Prism::Location) } + def keyword_loc; end - sig { params(names: T::Array[Node], keyword_loc: Location, location: Location).void } - def initialize(names, keyword_loc, location); end + sig { params(names: T::Array[Prism::Node], keyword_loc: Prism::Location, location: Prism::Location).void } + def initialize(names, keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(UndefNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::UndefNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `unless` keyword, either in the block form or the modifier form. - # - # bar unless foo - # ^^^^^^^^^^^^^^ - # - # unless foo then bar end - # ^^^^^^^^^^^^^^^^^^^^^^^ - class UnlessNode < Node - sig { returns(Location) } - attr_reader :keyword_loc +# Represents the use of the `unless` keyword, either in the block form or the modifier form. +# +# bar unless foo +# ^^^^^^^^^^^^^^ +# +# unless foo then bar end +# ^^^^^^^^^^^^^^^^^^^^^^^ +class Prism::UnlessNode < Prism::Node + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(Node) } - attr_reader :predicate + sig { returns(Prism::Node) } + def predicate; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(T.nilable(ElseNode)) } - attr_reader :consequent + sig { returns(T.nilable(Prism::ElseNode)) } + def consequent; end - sig { returns(T.nilable(Location)) } - attr_reader :end_keyword_loc + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end - sig { params(keyword_loc: Location, predicate: Node, statements: T.nilable(StatementsNode), consequent: T.nilable(ElseNode), end_keyword_loc: T.nilable(Location), location: Location).void } - def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + sig { params(keyword_loc: Prism::Location, predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void } + def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(UnlessNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::UnlessNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { returns(T.nilable(String)) } - def end_keyword; end + sig { returns(T.nilable(String)) } + def end_keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `until` keyword, either in the block form or the modifier form. - # - # bar until foo - # ^^^^^^^^^^^^^ - # - # until foo do bar end - # ^^^^^^^^^^^^^^^^^^^^ - class UntilNode < Node - sig { returns(Location) } - attr_reader :keyword_loc +# Represents the use of the `until` keyword, either in the block form or the modifier form. +# +# bar until foo +# ^^^^^^^^^^^^^ +# +# until foo do bar end +# ^^^^^^^^^^^^^^^^^^^^ +class Prism::UntilNode < Prism::Node + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { returns(Node) } - attr_reader :predicate + sig { returns(Prism::Node) } + def predicate; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(keyword_loc: Location, closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), flags: Integer, location: Location).void } - def initialize(keyword_loc, closing_loc, predicate, statements, flags, 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(UntilNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::UntilNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { returns(T::Boolean) } - def begin_modifier?; end + sig { returns(T::Boolean) } + def begin_modifier?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `when` keyword within a case statement. - # - # case true - # when true - # ^^^^^^^^^ - # end - class WhenNode < Node - sig { returns(Location) } - attr_reader :keyword_loc +# Represents the use of the `when` keyword within a case statement. +# +# case true +# when true +# ^^^^^^^^^ +# end +class Prism::WhenNode < Prism::Node + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(T::Array[Node]) } - attr_reader :conditions + sig { returns(T::Array[Prism::Node]) } + def conditions; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { params(keyword_loc: Location, conditions: T::Array[Node], statements: T.nilable(StatementsNode), location: Location).void } - def initialize(keyword_loc, conditions, statements, location); end + sig { params(keyword_loc: Prism::Location, conditions: T::Array[Prism::Node], statements: T.nilable(Prism::StatementsNode), location: Prism::Location).void } + def initialize(keyword_loc, conditions, statements, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(WhenNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::WhenNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `while` keyword, either in the block form or the modifier form. - # - # bar while foo - # ^^^^^^^^^^^^^ - # - # while foo do bar end - # ^^^^^^^^^^^^^^^^^^^^ - class WhileNode < Node - sig { returns(Location) } - attr_reader :keyword_loc +# Represents the use of the `while` keyword, either in the block form or the modifier form. +# +# bar while foo +# ^^^^^^^^^^^^^ +# +# while foo do bar end +# ^^^^^^^^^^^^^^^^^^^^ +class Prism::WhileNode < Prism::Node + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :closing_loc + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end - sig { returns(Node) } - attr_reader :predicate + sig { returns(Prism::Node) } + def predicate; end - sig { returns(T.nilable(StatementsNode)) } - attr_reader :statements + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end - sig { returns(Integer) } - attr_reader :flags + sig { returns(Integer) } + def flags; end - sig { params(keyword_loc: Location, closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), flags: Integer, location: Location).void } - def initialize(keyword_loc, closing_loc, predicate, statements, flags, 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: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - def set_newline_flag(newline_marked); end + def set_newline_flag(newline_marked); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(WhileNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::WhileNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { returns(T.nilable(String)) } - def closing; end + sig { returns(T.nilable(String)) } + def closing; end - sig { returns(T::Boolean) } - def begin_modifier?; end + sig { returns(T::Boolean) } + def begin_modifier?; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents an xstring literal with no interpolation. - # - # `foo` - # ^^^^^ - class XStringNode < Node - sig { returns(Location) } - attr_reader :opening_loc +# Represents an xstring literal with no interpolation. +# +# `foo` +# ^^^^^ +class Prism::XStringNode < Prism::Node + sig { returns(Prism::Location) } + def opening_loc; end - sig { returns(Location) } - attr_reader :content_loc + sig { returns(Prism::Location) } + def content_loc; end - sig { returns(Location) } - attr_reader :closing_loc + sig { returns(Prism::Location) } + def closing_loc; end - sig { returns(String) } - attr_reader :unescaped + sig { returns(String) } + def unescaped; end - sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location).void } - def initialize(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, location: Prism::Location).void } + def initialize(opening_loc, content_loc, closing_loc, unescaped, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(XStringNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::XStringNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 opening; end - sig { returns(String) } - def content; end + sig { returns(String) } + def content; end - sig { returns(String) } - def closing; end + sig { returns(String) } + def closing; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Represents the use of the `yield` keyword. - # - # yield 1 - # ^^^^^^^ - class YieldNode < Node - sig { returns(Location) } - attr_reader :keyword_loc +# Represents the use of the `yield` keyword. +# +# yield 1 +# ^^^^^^^ +class Prism::YieldNode < Prism::Node + sig { returns(Prism::Location) } + def keyword_loc; end - sig { returns(T.nilable(Location)) } - attr_reader :lparen_loc + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end - sig { returns(T.nilable(ArgumentsNode)) } - attr_reader :arguments + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end - sig { returns(T.nilable(Location)) } - attr_reader :rparen_loc + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end - sig { params(keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), location: Location).void } - def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, location); end + 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).void } + def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, location); end - sig { params(visitor: Visitor).void } - def accept(visitor); end + sig { params(visitor: Prism::Visitor).void } + def accept(visitor); end - sig { returns(T::Array[T.nilable(Node)]) } - def child_nodes; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end - sig { returns(T::Array[T.nilable(Node)]) } - def deconstruct; end + sig { returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end - sig { params(params: T.untyped).returns(YieldNode) } - def copy(**params); end + sig { params(params: T.untyped).returns(Prism::YieldNode) } + def copy(**params); end - sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } - def deconstruct_keys(keys); 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 keyword; end + sig { returns(String) } + def keyword; end - sig { returns(T.nilable(String)) } - def lparen; end + sig { returns(T.nilable(String)) } + def lparen; end - sig { returns(T.nilable(String)) } - def rparen; end + sig { returns(T.nilable(String)) } + def rparen; end - sig { params(inspector: NodeInspector).returns(String) } - def inspect(inspector); end - end + sig { params(inspector: Prism::NodeInspector).returns(String) } + def inspect(inspector); end +end - # Flags for arguments nodes. - module ArgumentsNodeFlags - # if arguments contain keyword splat - KEYWORD_SPLAT = T.let(1 << 0, Integer) - end +# Flags for arguments nodes. +module Prism::ArgumentsNodeFlags + # if arguments contain keyword splat + KEYWORD_SPLAT = T.let(1 << 0, Integer) +end - # Flags for call nodes. - module 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) - 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) +end - # Flags for integer nodes that correspond to the base of the integer. - module 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) - # 0x prefix - HEXADECIMAL = T.let(1 << 3, 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) + # 0x prefix + HEXADECIMAL = T.let(1 << 3, Integer) +end - # Flags for while and until loop nodes. - module LoopFlags - # a loop after a begin statement, so the body is executed first before the condition - BEGIN_MODIFIER = 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 - # Flags for range and flip-flop nodes. - module RangeFlags - # ... operator - EXCLUDE_END = T.let(1 << 0, Integer) - end +# Flags for range and flip-flop nodes. +module Prism::RangeFlags + # ... operator + EXCLUDE_END = T.let(1 << 0, Integer) +end - # Flags for regular expression and match last line nodes. - module RegularExpressionFlags - # i - ignores the case of characters when matching - IGNORE_CASE = T.let(1 << 0, Integer) - # x - ignores whitespace and allows comments in regular expressions - EXTENDED = T.let(1 << 1, Integer) - # m - allows $ to match the end of lines within strings - MULTI_LINE = T.let(1 << 2, Integer) - # o - only interpolates values into the regular expression once - ONCE = T.let(1 << 3, Integer) - # e - forces the EUC-JP encoding - EUC_JP = T.let(1 << 4, Integer) - # n - forces the ASCII-8BIT encoding - 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) - end +# Flags for regular expression and match last line nodes. +module Prism::RegularExpressionFlags + # i - ignores the case of characters when matching + IGNORE_CASE = T.let(1 << 0, Integer) + # x - ignores whitespace and allows comments in regular expressions + EXTENDED = T.let(1 << 1, Integer) + # m - allows $ to match the end of lines within strings + MULTI_LINE = T.let(1 << 2, Integer) + # o - only interpolates values into the regular expression once + ONCE = T.let(1 << 3, Integer) + # e - forces the EUC-JP encoding + EUC_JP = T.let(1 << 4, Integer) + # n - forces the ASCII-8BIT encoding + 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) +end - # Flags for string nodes. - module StringFlags - # frozen by virtue of a `frozen_string_literal` comment - FROZEN = T.let(1 << 0, Integer) - end +# Flags for string nodes. +module Prism::StringFlags + # frozen by virtue of a `frozen_string_literal` comment + FROZEN = T.let(1 << 0, Integer) +end - class Visitor < BasicVisitor - # Visit a AliasGlobalVariableNode node - sig { params(node: AliasGlobalVariableNode).void } - def visit_alias_global_variable_node(node); end - - # Visit a AliasMethodNode node - sig { params(node: AliasMethodNode).void } - def visit_alias_method_node(node); end - - # Visit a AlternationPatternNode node - sig { params(node: AlternationPatternNode).void } - def visit_alternation_pattern_node(node); end - - # Visit a AndNode node - sig { params(node: AndNode).void } - def visit_and_node(node); end - - # Visit a ArgumentsNode node - sig { params(node: ArgumentsNode).void } - def visit_arguments_node(node); end - - # Visit a ArrayNode node - sig { params(node: ArrayNode).void } - def visit_array_node(node); end - - # Visit a ArrayPatternNode node - sig { params(node: ArrayPatternNode).void } - def visit_array_pattern_node(node); end - - # Visit a AssocNode node - sig { params(node: AssocNode).void } - def visit_assoc_node(node); end - - # Visit a AssocSplatNode node - sig { params(node: AssocSplatNode).void } - def visit_assoc_splat_node(node); end - - # Visit a BackReferenceReadNode node - sig { params(node: BackReferenceReadNode).void } - def visit_back_reference_read_node(node); end - - # Visit a BeginNode node - sig { params(node: BeginNode).void } - def visit_begin_node(node); end - - # Visit a BlockArgumentNode node - sig { params(node: BlockArgumentNode).void } - def visit_block_argument_node(node); end - - # Visit a BlockLocalVariableNode node - sig { params(node: BlockLocalVariableNode).void } - def visit_block_local_variable_node(node); end - - # Visit a BlockNode node - sig { params(node: BlockNode).void } - def visit_block_node(node); end - - # Visit a BlockParameterNode node - sig { params(node: BlockParameterNode).void } - def visit_block_parameter_node(node); end - - # Visit a BlockParametersNode node - sig { params(node: BlockParametersNode).void } - def visit_block_parameters_node(node); end - - # Visit a BreakNode node - sig { params(node: BreakNode).void } - def visit_break_node(node); end - - # Visit a CallAndWriteNode node - sig { params(node: CallAndWriteNode).void } - def visit_call_and_write_node(node); end - - # Visit a CallNode node - sig { params(node: CallNode).void } - def visit_call_node(node); end - - # Visit a CallOperatorWriteNode node - sig { params(node: CallOperatorWriteNode).void } - def visit_call_operator_write_node(node); end - - # Visit a CallOrWriteNode node - sig { params(node: CallOrWriteNode).void } - def visit_call_or_write_node(node); end - - # Visit a CapturePatternNode node - sig { params(node: CapturePatternNode).void } - def visit_capture_pattern_node(node); end - - # Visit a CaseNode node - sig { params(node: CaseNode).void } - def visit_case_node(node); end - - # Visit a ClassNode node - sig { params(node: ClassNode).void } - def visit_class_node(node); end - - # Visit a ClassVariableAndWriteNode node - sig { params(node: ClassVariableAndWriteNode).void } - def visit_class_variable_and_write_node(node); end - - # Visit a ClassVariableOperatorWriteNode node - sig { params(node: ClassVariableOperatorWriteNode).void } - def visit_class_variable_operator_write_node(node); end - - # Visit a ClassVariableOrWriteNode node - sig { params(node: ClassVariableOrWriteNode).void } - def visit_class_variable_or_write_node(node); end - - # Visit a ClassVariableReadNode node - sig { params(node: ClassVariableReadNode).void } - def visit_class_variable_read_node(node); end - - # Visit a ClassVariableTargetNode node - sig { params(node: ClassVariableTargetNode).void } - def visit_class_variable_target_node(node); end - - # Visit a ClassVariableWriteNode node - sig { params(node: ClassVariableWriteNode).void } - def visit_class_variable_write_node(node); end - - # Visit a ConstantAndWriteNode node - sig { params(node: ConstantAndWriteNode).void } - def visit_constant_and_write_node(node); end - - # Visit a ConstantOperatorWriteNode node - sig { params(node: ConstantOperatorWriteNode).void } - def visit_constant_operator_write_node(node); end - - # Visit a ConstantOrWriteNode node - sig { params(node: ConstantOrWriteNode).void } - def visit_constant_or_write_node(node); end - - # Visit a ConstantPathAndWriteNode node - sig { params(node: ConstantPathAndWriteNode).void } - def visit_constant_path_and_write_node(node); end - - # Visit a ConstantPathNode node - sig { params(node: ConstantPathNode).void } - def visit_constant_path_node(node); end - - # Visit a ConstantPathOperatorWriteNode node - sig { params(node: ConstantPathOperatorWriteNode).void } - def visit_constant_path_operator_write_node(node); end - - # Visit a ConstantPathOrWriteNode node - sig { params(node: ConstantPathOrWriteNode).void } - def visit_constant_path_or_write_node(node); end - - # Visit a ConstantPathTargetNode node - sig { params(node: ConstantPathTargetNode).void } - def visit_constant_path_target_node(node); end - - # Visit a ConstantPathWriteNode node - sig { params(node: ConstantPathWriteNode).void } - def visit_constant_path_write_node(node); end - - # Visit a ConstantReadNode node - sig { params(node: ConstantReadNode).void } - def visit_constant_read_node(node); end - - # Visit a ConstantTargetNode node - sig { params(node: ConstantTargetNode).void } - def visit_constant_target_node(node); end - - # Visit a ConstantWriteNode node - sig { params(node: ConstantWriteNode).void } - def visit_constant_write_node(node); end - - # Visit a DefNode node - sig { params(node: DefNode).void } - def visit_def_node(node); end - - # Visit a DefinedNode node - sig { params(node: DefinedNode).void } - def visit_defined_node(node); end - - # Visit a ElseNode node - sig { params(node: ElseNode).void } - def visit_else_node(node); end - - # Visit a EmbeddedStatementsNode node - sig { params(node: EmbeddedStatementsNode).void } - def visit_embedded_statements_node(node); end - - # Visit a EmbeddedVariableNode node - sig { params(node: EmbeddedVariableNode).void } - def visit_embedded_variable_node(node); end - - # Visit a EnsureNode node - sig { params(node: EnsureNode).void } - def visit_ensure_node(node); end - - # Visit a FalseNode node - sig { params(node: FalseNode).void } - def visit_false_node(node); end - - # Visit a FindPatternNode node - sig { params(node: FindPatternNode).void } - def visit_find_pattern_node(node); end - - # Visit a FlipFlopNode node - sig { params(node: FlipFlopNode).void } - def visit_flip_flop_node(node); end - - # Visit a FloatNode node - sig { params(node: FloatNode).void } - def visit_float_node(node); end - - # Visit a ForNode node - sig { params(node: ForNode).void } - def visit_for_node(node); end - - # Visit a ForwardingArgumentsNode node - sig { params(node: ForwardingArgumentsNode).void } - def visit_forwarding_arguments_node(node); end - - # Visit a ForwardingParameterNode node - sig { params(node: ForwardingParameterNode).void } - def visit_forwarding_parameter_node(node); end - - # Visit a ForwardingSuperNode node - sig { params(node: ForwardingSuperNode).void } - def visit_forwarding_super_node(node); end - - # Visit a GlobalVariableAndWriteNode node - sig { params(node: GlobalVariableAndWriteNode).void } - def visit_global_variable_and_write_node(node); end - - # Visit a GlobalVariableOperatorWriteNode node - sig { params(node: GlobalVariableOperatorWriteNode).void } - def visit_global_variable_operator_write_node(node); end - - # Visit a GlobalVariableOrWriteNode node - sig { params(node: GlobalVariableOrWriteNode).void } - def visit_global_variable_or_write_node(node); end - - # Visit a GlobalVariableReadNode node - sig { params(node: GlobalVariableReadNode).void } - def visit_global_variable_read_node(node); end - - # Visit a GlobalVariableTargetNode node - sig { params(node: GlobalVariableTargetNode).void } - def visit_global_variable_target_node(node); end - - # Visit a GlobalVariableWriteNode node - sig { params(node: GlobalVariableWriteNode).void } - def visit_global_variable_write_node(node); end - - # Visit a HashNode node - sig { params(node: HashNode).void } - def visit_hash_node(node); end - - # Visit a HashPatternNode node - sig { params(node: HashPatternNode).void } - def visit_hash_pattern_node(node); end - - # Visit a IfNode node - sig { params(node: IfNode).void } - def visit_if_node(node); end - - # Visit a ImaginaryNode node - sig { params(node: ImaginaryNode).void } - def visit_imaginary_node(node); end - - # Visit a ImplicitNode node - sig { params(node: ImplicitNode).void } - def visit_implicit_node(node); end - - # Visit a InNode node - sig { params(node: InNode).void } - def visit_in_node(node); end - - # Visit a IndexAndWriteNode node - sig { params(node: IndexAndWriteNode).void } - def visit_index_and_write_node(node); end - - # Visit a IndexOperatorWriteNode node - sig { params(node: IndexOperatorWriteNode).void } - def visit_index_operator_write_node(node); end - - # Visit a IndexOrWriteNode node - sig { params(node: IndexOrWriteNode).void } - def visit_index_or_write_node(node); end - - # Visit a InstanceVariableAndWriteNode node - sig { params(node: InstanceVariableAndWriteNode).void } - def visit_instance_variable_and_write_node(node); end - - # Visit a InstanceVariableOperatorWriteNode node - sig { params(node: InstanceVariableOperatorWriteNode).void } - def visit_instance_variable_operator_write_node(node); end - - # Visit a InstanceVariableOrWriteNode node - sig { params(node: InstanceVariableOrWriteNode).void } - def visit_instance_variable_or_write_node(node); end - - # Visit a InstanceVariableReadNode node - sig { params(node: InstanceVariableReadNode).void } - def visit_instance_variable_read_node(node); end - - # Visit a InstanceVariableTargetNode node - sig { params(node: InstanceVariableTargetNode).void } - def visit_instance_variable_target_node(node); end - - # Visit a InstanceVariableWriteNode node - sig { params(node: InstanceVariableWriteNode).void } - def visit_instance_variable_write_node(node); end - - # Visit a IntegerNode node - sig { params(node: IntegerNode).void } - def visit_integer_node(node); end - - # Visit a InterpolatedMatchLastLineNode node - sig { params(node: InterpolatedMatchLastLineNode).void } - def visit_interpolated_match_last_line_node(node); end - - # Visit a InterpolatedRegularExpressionNode node - sig { params(node: InterpolatedRegularExpressionNode).void } - def visit_interpolated_regular_expression_node(node); end - - # Visit a InterpolatedStringNode node - sig { params(node: InterpolatedStringNode).void } - def visit_interpolated_string_node(node); end - - # Visit a InterpolatedSymbolNode node - sig { params(node: InterpolatedSymbolNode).void } - def visit_interpolated_symbol_node(node); end - - # Visit a InterpolatedXStringNode node - sig { params(node: InterpolatedXStringNode).void } - def visit_interpolated_x_string_node(node); end - - # Visit a KeywordHashNode node - sig { params(node: KeywordHashNode).void } - def visit_keyword_hash_node(node); end - - # Visit a KeywordRestParameterNode node - sig { params(node: KeywordRestParameterNode).void } - def visit_keyword_rest_parameter_node(node); end - - # Visit a LambdaNode node - sig { params(node: LambdaNode).void } - def visit_lambda_node(node); end - - # Visit a LocalVariableAndWriteNode node - sig { params(node: LocalVariableAndWriteNode).void } - def visit_local_variable_and_write_node(node); end - - # Visit a LocalVariableOperatorWriteNode node - sig { params(node: LocalVariableOperatorWriteNode).void } - def visit_local_variable_operator_write_node(node); end - - # Visit a LocalVariableOrWriteNode node - sig { params(node: LocalVariableOrWriteNode).void } - def visit_local_variable_or_write_node(node); end - - # Visit a LocalVariableReadNode node - sig { params(node: LocalVariableReadNode).void } - def visit_local_variable_read_node(node); end - - # Visit a LocalVariableTargetNode node - sig { params(node: LocalVariableTargetNode).void } - def visit_local_variable_target_node(node); end - - # Visit a LocalVariableWriteNode node - sig { params(node: LocalVariableWriteNode).void } - def visit_local_variable_write_node(node); end - - # Visit a MatchLastLineNode node - sig { params(node: MatchLastLineNode).void } - def visit_match_last_line_node(node); end - - # Visit a MatchPredicateNode node - sig { params(node: MatchPredicateNode).void } - def visit_match_predicate_node(node); end - - # Visit a MatchRequiredNode node - sig { params(node: MatchRequiredNode).void } - def visit_match_required_node(node); end - - # Visit a MatchWriteNode node - sig { params(node: MatchWriteNode).void } - def visit_match_write_node(node); end - - # Visit a MissingNode node - sig { params(node: MissingNode).void } - def visit_missing_node(node); end - - # Visit a ModuleNode node - sig { params(node: ModuleNode).void } - def visit_module_node(node); end - - # Visit a MultiTargetNode node - sig { params(node: MultiTargetNode).void } - def visit_multi_target_node(node); end - - # Visit a MultiWriteNode node - sig { params(node: MultiWriteNode).void } - def visit_multi_write_node(node); end - - # Visit a NextNode node - sig { params(node: NextNode).void } - def visit_next_node(node); end - - # Visit a NilNode node - sig { params(node: NilNode).void } - def visit_nil_node(node); end - - # Visit a NoKeywordsParameterNode node - sig { params(node: NoKeywordsParameterNode).void } - def visit_no_keywords_parameter_node(node); end - - # Visit a NumberedReferenceReadNode node - sig { params(node: NumberedReferenceReadNode).void } - def visit_numbered_reference_read_node(node); end - - # Visit a OptionalKeywordParameterNode node - sig { params(node: OptionalKeywordParameterNode).void } - def visit_optional_keyword_parameter_node(node); end - - # Visit a OptionalParameterNode node - sig { params(node: OptionalParameterNode).void } - def visit_optional_parameter_node(node); end - - # Visit a OrNode node - sig { params(node: OrNode).void } - def visit_or_node(node); end - - # Visit a ParametersNode node - sig { params(node: ParametersNode).void } - def visit_parameters_node(node); end - - # Visit a ParenthesesNode node - sig { params(node: ParenthesesNode).void } - def visit_parentheses_node(node); end - - # Visit a PinnedExpressionNode node - sig { params(node: PinnedExpressionNode).void } - def visit_pinned_expression_node(node); end - - # Visit a PinnedVariableNode node - sig { params(node: PinnedVariableNode).void } - def visit_pinned_variable_node(node); end - - # Visit a PostExecutionNode node - sig { params(node: PostExecutionNode).void } - def visit_post_execution_node(node); end - - # Visit a PreExecutionNode node - sig { params(node: PreExecutionNode).void } - def visit_pre_execution_node(node); end - - # Visit a ProgramNode node - sig { params(node: ProgramNode).void } - def visit_program_node(node); end - - # Visit a RangeNode node - sig { params(node: RangeNode).void } - def visit_range_node(node); end - - # Visit a RationalNode node - sig { params(node: RationalNode).void } - def visit_rational_node(node); end - - # Visit a RedoNode node - sig { params(node: RedoNode).void } - def visit_redo_node(node); end - - # Visit a RegularExpressionNode node - sig { params(node: RegularExpressionNode).void } - def visit_regular_expression_node(node); end - - # Visit a RequiredKeywordParameterNode node - sig { params(node: RequiredKeywordParameterNode).void } - def visit_required_keyword_parameter_node(node); end - - # Visit a RequiredParameterNode node - sig { params(node: RequiredParameterNode).void } - def visit_required_parameter_node(node); end - - # Visit a RescueModifierNode node - sig { params(node: RescueModifierNode).void } - def visit_rescue_modifier_node(node); end - - # Visit a RescueNode node - sig { params(node: RescueNode).void } - def visit_rescue_node(node); end - - # Visit a RestParameterNode node - sig { params(node: RestParameterNode).void } - def visit_rest_parameter_node(node); end - - # Visit a RetryNode node - sig { params(node: RetryNode).void } - def visit_retry_node(node); end - - # Visit a ReturnNode node - sig { params(node: ReturnNode).void } - def visit_return_node(node); end - - # Visit a SelfNode node - sig { params(node: SelfNode).void } - def visit_self_node(node); end - - # Visit a SingletonClassNode node - sig { params(node: SingletonClassNode).void } - def visit_singleton_class_node(node); end - - # Visit a SourceEncodingNode node - sig { params(node: SourceEncodingNode).void } - def visit_source_encoding_node(node); end - - # Visit a SourceFileNode node - sig { params(node: SourceFileNode).void } - def visit_source_file_node(node); end - - # Visit a SourceLineNode node - sig { params(node: SourceLineNode).void } - def visit_source_line_node(node); end - - # Visit a SplatNode node - sig { params(node: SplatNode).void } - def visit_splat_node(node); end - - # Visit a StatementsNode node - sig { params(node: StatementsNode).void } - def visit_statements_node(node); end - - # Visit a StringConcatNode node - sig { params(node: StringConcatNode).void } - def visit_string_concat_node(node); end - - # Visit a StringNode node - sig { params(node: StringNode).void } - def visit_string_node(node); end - - # Visit a SuperNode node - sig { params(node: SuperNode).void } - def visit_super_node(node); end - - # Visit a SymbolNode node - sig { params(node: SymbolNode).void } - def visit_symbol_node(node); end - - # Visit a TrueNode node - sig { params(node: TrueNode).void } - def visit_true_node(node); end - - # Visit a UndefNode node - sig { params(node: UndefNode).void } - def visit_undef_node(node); end - - # Visit a UnlessNode node - sig { params(node: UnlessNode).void } - def visit_unless_node(node); end - - # Visit a UntilNode node - sig { params(node: UntilNode).void } - def visit_until_node(node); end - - # Visit a WhenNode node - sig { params(node: WhenNode).void } - def visit_when_node(node); end - - # Visit a WhileNode node - sig { params(node: WhileNode).void } - def visit_while_node(node); end - - # Visit a XStringNode node - sig { params(node: XStringNode).void } - def visit_x_string_node(node); end - - # Visit a YieldNode node - sig { params(node: YieldNode).void } - def visit_yield_node(node); end - end +class Prism::Visitor < Prism::BasicVisitor + # Visit a AliasGlobalVariableNode node + sig { params(node: Prism::AliasGlobalVariableNode).void } + def visit_alias_global_variable_node(node); end + + # Visit a AliasMethodNode node + sig { params(node: Prism::AliasMethodNode).void } + def visit_alias_method_node(node); end + + # Visit a AlternationPatternNode node + sig { params(node: Prism::AlternationPatternNode).void } + def visit_alternation_pattern_node(node); end + + # Visit a AndNode node + sig { params(node: Prism::AndNode).void } + def visit_and_node(node); end + + # Visit a ArgumentsNode node + sig { params(node: Prism::ArgumentsNode).void } + def visit_arguments_node(node); end + + # Visit a ArrayNode node + sig { params(node: Prism::ArrayNode).void } + def visit_array_node(node); end + + # Visit a ArrayPatternNode node + sig { params(node: Prism::ArrayPatternNode).void } + def visit_array_pattern_node(node); end + + # Visit a AssocNode node + sig { params(node: Prism::AssocNode).void } + def visit_assoc_node(node); end + + # Visit a AssocSplatNode node + sig { params(node: Prism::AssocSplatNode).void } + def visit_assoc_splat_node(node); end + + # Visit a BackReferenceReadNode node + sig { params(node: Prism::BackReferenceReadNode).void } + def visit_back_reference_read_node(node); end + + # Visit a BeginNode node + sig { params(node: Prism::BeginNode).void } + def visit_begin_node(node); end + + # Visit a BlockArgumentNode node + sig { params(node: Prism::BlockArgumentNode).void } + def visit_block_argument_node(node); end + + # Visit a BlockLocalVariableNode node + sig { params(node: Prism::BlockLocalVariableNode).void } + def visit_block_local_variable_node(node); end + + # Visit a BlockNode node + sig { params(node: Prism::BlockNode).void } + def visit_block_node(node); end + + # Visit a BlockParameterNode node + sig { params(node: Prism::BlockParameterNode).void } + def visit_block_parameter_node(node); end + + # Visit a BlockParametersNode node + sig { params(node: Prism::BlockParametersNode).void } + def visit_block_parameters_node(node); end + + # Visit a BreakNode node + sig { params(node: Prism::BreakNode).void } + def visit_break_node(node); end + + # Visit a CallAndWriteNode node + sig { params(node: Prism::CallAndWriteNode).void } + def visit_call_and_write_node(node); end + + # Visit a CallNode node + sig { params(node: Prism::CallNode).void } + def visit_call_node(node); end + + # Visit a CallOperatorWriteNode node + sig { params(node: Prism::CallOperatorWriteNode).void } + def visit_call_operator_write_node(node); end + + # Visit a CallOrWriteNode node + sig { params(node: Prism::CallOrWriteNode).void } + def visit_call_or_write_node(node); end + + # Visit a CapturePatternNode node + sig { params(node: Prism::CapturePatternNode).void } + def visit_capture_pattern_node(node); end + + # Visit a CaseNode node + sig { params(node: Prism::CaseNode).void } + def visit_case_node(node); end + + # Visit a ClassNode node + sig { params(node: Prism::ClassNode).void } + def visit_class_node(node); end + + # Visit a ClassVariableAndWriteNode node + sig { params(node: Prism::ClassVariableAndWriteNode).void } + def visit_class_variable_and_write_node(node); end + + # Visit a ClassVariableOperatorWriteNode node + sig { params(node: Prism::ClassVariableOperatorWriteNode).void } + def visit_class_variable_operator_write_node(node); end + + # Visit a ClassVariableOrWriteNode node + sig { params(node: Prism::ClassVariableOrWriteNode).void } + def visit_class_variable_or_write_node(node); end + + # Visit a ClassVariableReadNode node + sig { params(node: Prism::ClassVariableReadNode).void } + def visit_class_variable_read_node(node); end + + # Visit a ClassVariableTargetNode node + sig { params(node: Prism::ClassVariableTargetNode).void } + def visit_class_variable_target_node(node); end + + # Visit a ClassVariableWriteNode node + sig { params(node: Prism::ClassVariableWriteNode).void } + def visit_class_variable_write_node(node); end + + # Visit a ConstantAndWriteNode node + sig { params(node: Prism::ConstantAndWriteNode).void } + def visit_constant_and_write_node(node); end + + # Visit a ConstantOperatorWriteNode node + sig { params(node: Prism::ConstantOperatorWriteNode).void } + def visit_constant_operator_write_node(node); end + + # Visit a ConstantOrWriteNode node + sig { params(node: Prism::ConstantOrWriteNode).void } + def visit_constant_or_write_node(node); end + + # Visit a ConstantPathAndWriteNode node + sig { params(node: Prism::ConstantPathAndWriteNode).void } + def visit_constant_path_and_write_node(node); end + + # Visit a ConstantPathNode node + sig { params(node: Prism::ConstantPathNode).void } + def visit_constant_path_node(node); end + + # Visit a ConstantPathOperatorWriteNode node + sig { params(node: Prism::ConstantPathOperatorWriteNode).void } + def visit_constant_path_operator_write_node(node); end + + # Visit a ConstantPathOrWriteNode node + sig { params(node: Prism::ConstantPathOrWriteNode).void } + def visit_constant_path_or_write_node(node); end + + # Visit a ConstantPathTargetNode node + sig { params(node: Prism::ConstantPathTargetNode).void } + def visit_constant_path_target_node(node); end + + # Visit a ConstantPathWriteNode node + sig { params(node: Prism::ConstantPathWriteNode).void } + def visit_constant_path_write_node(node); end + + # Visit a ConstantReadNode node + sig { params(node: Prism::ConstantReadNode).void } + def visit_constant_read_node(node); end + + # Visit a ConstantTargetNode node + sig { params(node: Prism::ConstantTargetNode).void } + def visit_constant_target_node(node); end + + # Visit a ConstantWriteNode node + sig { params(node: Prism::ConstantWriteNode).void } + def visit_constant_write_node(node); end + + # Visit a DefNode node + sig { params(node: Prism::DefNode).void } + def visit_def_node(node); end + + # Visit a DefinedNode node + sig { params(node: Prism::DefinedNode).void } + def visit_defined_node(node); end + + # Visit a ElseNode node + sig { params(node: Prism::ElseNode).void } + def visit_else_node(node); end + + # Visit a EmbeddedStatementsNode node + sig { params(node: Prism::EmbeddedStatementsNode).void } + def visit_embedded_statements_node(node); end + + # Visit a EmbeddedVariableNode node + sig { params(node: Prism::EmbeddedVariableNode).void } + def visit_embedded_variable_node(node); end + + # Visit a EnsureNode node + sig { params(node: Prism::EnsureNode).void } + def visit_ensure_node(node); end + + # Visit a FalseNode node + sig { params(node: Prism::FalseNode).void } + def visit_false_node(node); end + + # Visit a FindPatternNode node + sig { params(node: Prism::FindPatternNode).void } + def visit_find_pattern_node(node); end + + # Visit a FlipFlopNode node + sig { params(node: Prism::FlipFlopNode).void } + def visit_flip_flop_node(node); end + + # Visit a FloatNode node + sig { params(node: Prism::FloatNode).void } + def visit_float_node(node); end + + # Visit a ForNode node + sig { params(node: Prism::ForNode).void } + def visit_for_node(node); end + + # Visit a ForwardingArgumentsNode node + sig { params(node: Prism::ForwardingArgumentsNode).void } + def visit_forwarding_arguments_node(node); end + + # Visit a ForwardingParameterNode node + sig { params(node: Prism::ForwardingParameterNode).void } + def visit_forwarding_parameter_node(node); end + + # Visit a ForwardingSuperNode node + sig { params(node: Prism::ForwardingSuperNode).void } + def visit_forwarding_super_node(node); end + + # Visit a GlobalVariableAndWriteNode node + sig { params(node: Prism::GlobalVariableAndWriteNode).void } + def visit_global_variable_and_write_node(node); end + + # Visit a GlobalVariableOperatorWriteNode node + sig { params(node: Prism::GlobalVariableOperatorWriteNode).void } + def visit_global_variable_operator_write_node(node); end + + # Visit a GlobalVariableOrWriteNode node + sig { params(node: Prism::GlobalVariableOrWriteNode).void } + def visit_global_variable_or_write_node(node); end + + # Visit a GlobalVariableReadNode node + sig { params(node: Prism::GlobalVariableReadNode).void } + def visit_global_variable_read_node(node); end + + # Visit a GlobalVariableTargetNode node + sig { params(node: Prism::GlobalVariableTargetNode).void } + def visit_global_variable_target_node(node); end + + # Visit a GlobalVariableWriteNode node + sig { params(node: Prism::GlobalVariableWriteNode).void } + def visit_global_variable_write_node(node); end + + # Visit a HashNode node + sig { params(node: Prism::HashNode).void } + def visit_hash_node(node); end + + # Visit a HashPatternNode node + sig { params(node: Prism::HashPatternNode).void } + def visit_hash_pattern_node(node); end + + # Visit a IfNode node + sig { params(node: Prism::IfNode).void } + def visit_if_node(node); end + + # Visit a ImaginaryNode node + sig { params(node: Prism::ImaginaryNode).void } + def visit_imaginary_node(node); end + + # Visit a ImplicitNode node + sig { params(node: Prism::ImplicitNode).void } + def visit_implicit_node(node); end + + # Visit a InNode node + sig { params(node: Prism::InNode).void } + def visit_in_node(node); end + + # Visit a IndexAndWriteNode node + sig { params(node: Prism::IndexAndWriteNode).void } + def visit_index_and_write_node(node); end + + # Visit a IndexOperatorWriteNode node + sig { params(node: Prism::IndexOperatorWriteNode).void } + def visit_index_operator_write_node(node); end + + # Visit a IndexOrWriteNode node + sig { params(node: Prism::IndexOrWriteNode).void } + def visit_index_or_write_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 + sig { params(node: Prism::InstanceVariableOperatorWriteNode).void } + def visit_instance_variable_operator_write_node(node); end + + # Visit a InstanceVariableOrWriteNode node + sig { params(node: Prism::InstanceVariableOrWriteNode).void } + def visit_instance_variable_or_write_node(node); end + + # Visit a InstanceVariableReadNode node + sig { params(node: Prism::InstanceVariableReadNode).void } + def visit_instance_variable_read_node(node); end + + # Visit a InstanceVariableTargetNode node + sig { params(node: Prism::InstanceVariableTargetNode).void } + def visit_instance_variable_target_node(node); end + + # Visit a InstanceVariableWriteNode node + sig { params(node: Prism::InstanceVariableWriteNode).void } + def visit_instance_variable_write_node(node); end + + # Visit a IntegerNode node + sig { params(node: Prism::IntegerNode).void } + def visit_integer_node(node); end + + # Visit a InterpolatedMatchLastLineNode node + sig { params(node: Prism::InterpolatedMatchLastLineNode).void } + def visit_interpolated_match_last_line_node(node); end + + # Visit a InterpolatedRegularExpressionNode node + sig { params(node: Prism::InterpolatedRegularExpressionNode).void } + def visit_interpolated_regular_expression_node(node); end + + # Visit a InterpolatedStringNode node + sig { params(node: Prism::InterpolatedStringNode).void } + def visit_interpolated_string_node(node); end + + # Visit a InterpolatedSymbolNode node + sig { params(node: Prism::InterpolatedSymbolNode).void } + def visit_interpolated_symbol_node(node); end + + # Visit a InterpolatedXStringNode node + sig { params(node: Prism::InterpolatedXStringNode).void } + def visit_interpolated_x_string_node(node); end + + # Visit a KeywordHashNode node + sig { params(node: Prism::KeywordHashNode).void } + def visit_keyword_hash_node(node); end + + # Visit a KeywordRestParameterNode node + sig { params(node: Prism::KeywordRestParameterNode).void } + def visit_keyword_rest_parameter_node(node); end + + # Visit a LambdaNode node + sig { params(node: Prism::LambdaNode).void } + def visit_lambda_node(node); end + + # Visit a LocalVariableAndWriteNode node + sig { params(node: Prism::LocalVariableAndWriteNode).void } + def visit_local_variable_and_write_node(node); end + + # Visit a LocalVariableOperatorWriteNode node + sig { params(node: Prism::LocalVariableOperatorWriteNode).void } + def visit_local_variable_operator_write_node(node); end + + # Visit a LocalVariableOrWriteNode node + sig { params(node: Prism::LocalVariableOrWriteNode).void } + def visit_local_variable_or_write_node(node); end + + # Visit a LocalVariableReadNode node + sig { params(node: Prism::LocalVariableReadNode).void } + def visit_local_variable_read_node(node); end + + # Visit a LocalVariableTargetNode node + sig { params(node: Prism::LocalVariableTargetNode).void } + def visit_local_variable_target_node(node); end + + # Visit a LocalVariableWriteNode node + sig { params(node: Prism::LocalVariableWriteNode).void } + def visit_local_variable_write_node(node); end + + # Visit a MatchLastLineNode node + sig { params(node: Prism::MatchLastLineNode).void } + def visit_match_last_line_node(node); end + + # Visit a MatchPredicateNode node + sig { params(node: Prism::MatchPredicateNode).void } + def visit_match_predicate_node(node); end + + # Visit a MatchRequiredNode node + sig { params(node: Prism::MatchRequiredNode).void } + def visit_match_required_node(node); end + + # Visit a MatchWriteNode node + sig { params(node: Prism::MatchWriteNode).void } + def visit_match_write_node(node); end + + # Visit a MissingNode node + sig { params(node: Prism::MissingNode).void } + def visit_missing_node(node); end + + # Visit a ModuleNode node + sig { params(node: Prism::ModuleNode).void } + def visit_module_node(node); end + + # Visit a MultiTargetNode node + sig { params(node: Prism::MultiTargetNode).void } + def visit_multi_target_node(node); end + + # Visit a MultiWriteNode node + sig { params(node: Prism::MultiWriteNode).void } + def visit_multi_write_node(node); end + + # Visit a NextNode node + sig { params(node: Prism::NextNode).void } + def visit_next_node(node); end + + # Visit a NilNode node + sig { params(node: Prism::NilNode).void } + def visit_nil_node(node); end + + # Visit a NoKeywordsParameterNode node + sig { params(node: Prism::NoKeywordsParameterNode).void } + def visit_no_keywords_parameter_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 + sig { params(node: Prism::OptionalKeywordParameterNode).void } + def visit_optional_keyword_parameter_node(node); end + + # Visit a OptionalParameterNode node + sig { params(node: Prism::OptionalParameterNode).void } + def visit_optional_parameter_node(node); end + + # Visit a OrNode node + sig { params(node: Prism::OrNode).void } + def visit_or_node(node); end + + # Visit a ParametersNode node + sig { params(node: Prism::ParametersNode).void } + def visit_parameters_node(node); end + + # Visit a ParenthesesNode node + sig { params(node: Prism::ParenthesesNode).void } + def visit_parentheses_node(node); end + + # Visit a PinnedExpressionNode node + sig { params(node: Prism::PinnedExpressionNode).void } + def visit_pinned_expression_node(node); end + + # Visit a PinnedVariableNode node + sig { params(node: Prism::PinnedVariableNode).void } + def visit_pinned_variable_node(node); end + + # Visit a PostExecutionNode node + sig { params(node: Prism::PostExecutionNode).void } + def visit_post_execution_node(node); end + + # Visit a PreExecutionNode node + sig { params(node: Prism::PreExecutionNode).void } + def visit_pre_execution_node(node); end + + # Visit a ProgramNode node + sig { params(node: Prism::ProgramNode).void } + def visit_program_node(node); end + + # Visit a RangeNode node + sig { params(node: Prism::RangeNode).void } + def visit_range_node(node); end + + # Visit a RationalNode node + sig { params(node: Prism::RationalNode).void } + def visit_rational_node(node); end + + # Visit a RedoNode node + sig { params(node: Prism::RedoNode).void } + def visit_redo_node(node); end + + # Visit a RegularExpressionNode node + sig { params(node: Prism::RegularExpressionNode).void } + def visit_regular_expression_node(node); end + + # Visit a RequiredKeywordParameterNode node + sig { params(node: Prism::RequiredKeywordParameterNode).void } + def visit_required_keyword_parameter_node(node); end + + # Visit a RequiredParameterNode node + sig { params(node: Prism::RequiredParameterNode).void } + def visit_required_parameter_node(node); end + + # Visit a RescueModifierNode node + sig { params(node: Prism::RescueModifierNode).void } + def visit_rescue_modifier_node(node); end + + # Visit a RescueNode node + sig { params(node: Prism::RescueNode).void } + def visit_rescue_node(node); end + + # Visit a RestParameterNode node + sig { params(node: Prism::RestParameterNode).void } + def visit_rest_parameter_node(node); end + + # Visit a RetryNode node + sig { params(node: Prism::RetryNode).void } + def visit_retry_node(node); end + + # Visit a ReturnNode node + sig { params(node: Prism::ReturnNode).void } + def visit_return_node(node); end + + # Visit a SelfNode node + sig { params(node: Prism::SelfNode).void } + def visit_self_node(node); end + + # Visit a SingletonClassNode node + sig { params(node: Prism::SingletonClassNode).void } + def visit_singleton_class_node(node); end + + # Visit a SourceEncodingNode node + sig { params(node: Prism::SourceEncodingNode).void } + def visit_source_encoding_node(node); end + + # Visit a SourceFileNode node + sig { params(node: Prism::SourceFileNode).void } + def visit_source_file_node(node); end + + # Visit a SourceLineNode node + sig { params(node: Prism::SourceLineNode).void } + def visit_source_line_node(node); end + + # Visit a SplatNode node + sig { params(node: Prism::SplatNode).void } + def visit_splat_node(node); end + + # Visit a StatementsNode node + sig { params(node: Prism::StatementsNode).void } + def visit_statements_node(node); end + + # Visit a StringConcatNode node + sig { params(node: Prism::StringConcatNode).void } + def visit_string_concat_node(node); end + + # Visit a StringNode node + sig { params(node: Prism::StringNode).void } + def visit_string_node(node); end + + # Visit a SuperNode node + sig { params(node: Prism::SuperNode).void } + def visit_super_node(node); end + + # Visit a SymbolNode node + sig { params(node: Prism::SymbolNode).void } + def visit_symbol_node(node); end + + # Visit a TrueNode node + sig { params(node: Prism::TrueNode).void } + def visit_true_node(node); end + + # Visit a UndefNode node + sig { params(node: Prism::UndefNode).void } + def visit_undef_node(node); end + + # Visit a UnlessNode node + sig { params(node: Prism::UnlessNode).void } + def visit_unless_node(node); end + + # Visit a UntilNode node + sig { params(node: Prism::UntilNode).void } + def visit_until_node(node); end + + # Visit a WhenNode node + sig { params(node: Prism::WhenNode).void } + def visit_when_node(node); end + + # Visit a WhileNode node + sig { params(node: Prism::WhileNode).void } + def visit_while_node(node); end + + # Visit a XStringNode node + sig { params(node: Prism::XStringNode).void } + def visit_x_string_node(node); end + + # Visit a YieldNode node + sig { params(node: Prism::YieldNode).void } + def visit_yield_node(node); end + end - module DSL - private +module Prism::DSL + private - # Create a new Location object - sig { params(source: T.nilable(Source), start_offset: Integer, length: Integer).returns(Location) } - def Location(source, start_offset, length); end + # Create a new Location object + sig { params(source: T.nilable(Source), start_offset: Integer, length: Integer).returns(Prism::Location) } + def Location(source, start_offset, length); end - # Create a new AliasGlobalVariableNode node - sig { params(new_name: Node, old_name: Node, keyword_loc: Location, location: Location).returns(AliasGlobalVariableNode) } - def AliasGlobalVariableNode(new_name, old_name, keyword_loc, location); end - # Create a new AliasMethodNode node - sig { params(new_name: Node, old_name: Node, keyword_loc: Location, location: Location).returns(AliasMethodNode) } - def AliasMethodNode(new_name, old_name, keyword_loc, location); end - # Create a new AlternationPatternNode node - sig { params(left: Node, right: Node, operator_loc: Location, location: Location).returns(AlternationPatternNode) } - def AlternationPatternNode(left, right, operator_loc, location); end - # Create a new AndNode node - sig { params(left: Node, right: Node, operator_loc: Location, location: Location).returns(AndNode) } - def AndNode(left, right, operator_loc, location); end - # Create a new ArgumentsNode node - sig { params(arguments: T::Array[Node], flags: Integer, location: Location).returns(ArgumentsNode) } - def ArgumentsNode(arguments, flags, location); end - # Create a new ArrayNode node - sig { params(elements: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(ArrayNode) } - def ArrayNode(elements, opening_loc, closing_loc, location); end - # Create a new ArrayPatternNode node - sig { params(constant: T.nilable(Node), requireds: T::Array[Node], rest: T.nilable(Node), posts: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(ArrayPatternNode) } - def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location); end - # Create a new AssocNode node - sig { params(key: Node, value: T.nilable(Node), operator_loc: T.nilable(Location), location: Location).returns(AssocNode) } - def AssocNode(key, value, operator_loc, location); end - # Create a new AssocSplatNode node - sig { params(value: T.nilable(Node), operator_loc: Location, location: Location).returns(AssocSplatNode) } - def AssocSplatNode(value, operator_loc, location); end - # Create a new BackReferenceReadNode node - sig { params(name: Symbol, location: Location).returns(BackReferenceReadNode) } - def BackReferenceReadNode(name, location); end - # Create a new BeginNode node - sig { params(begin_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), rescue_clause: T.nilable(RescueNode), else_clause: T.nilable(ElseNode), ensure_clause: T.nilable(EnsureNode), end_keyword_loc: T.nilable(Location), location: Location).returns(BeginNode) } - def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end - # Create a new BlockArgumentNode node - sig { params(expression: T.nilable(Node), operator_loc: Location, location: Location).returns(BlockArgumentNode) } - def BlockArgumentNode(expression, operator_loc, location); end - # Create a new BlockLocalVariableNode node - sig { params(name: Symbol, location: Location).returns(BlockLocalVariableNode) } - def BlockLocalVariableNode(name, location); end - # Create a new BlockNode node - sig { params(locals: T::Array[Symbol], parameters: T.nilable(BlockParametersNode), body: T.nilable(Node), opening_loc: Location, closing_loc: Location, location: Location).returns(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(Location), operator_loc: Location, location: Location).returns(BlockParameterNode) } - def BlockParameterNode(name, name_loc, operator_loc, location); end - # Create a new BlockParametersNode node - sig { params(parameters: T.nilable(ParametersNode), locals: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(BlockParametersNode) } - def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location); end - # Create a new BreakNode node - sig { params(arguments: T.nilable(ArgumentsNode), keyword_loc: Location, location: Location).returns(BreakNode) } - def BreakNode(arguments, keyword_loc, location); end - # Create a new CallAndWriteNode node - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location).returns(CallAndWriteNode) } - def CallAndWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location); end - # Create a new CallNode node - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), block: T.nilable(Node), flags: Integer, name: Symbol, location: Location).returns(CallNode) } - def CallNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location); end - # Create a new CallOperatorWriteNode node - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location).returns(CallOperatorWriteNode) } - def CallOperatorWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location); end - # Create a new CallOrWriteNode node - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location).returns(CallOrWriteNode) } - def CallOrWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location); end - # Create a new CapturePatternNode node - sig { params(value: Node, target: Node, operator_loc: Location, location: Location).returns(CapturePatternNode) } - def CapturePatternNode(value, target, operator_loc, location); end - # Create a new CaseNode node - sig { params(predicate: T.nilable(Node), conditions: T::Array[Node], consequent: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location, location: Location).returns(CaseNode) } - def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end - # Create a new ClassNode node - sig { params(locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: T.nilable(Location), superclass: T.nilable(Node), body: T.nilable(Node), end_keyword_loc: Location, name: Symbol, location: Location).returns(ClassNode) } - def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end - # Create a new ClassVariableAndWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(ClassVariableAndWriteNode) } - def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location); end - # Create a new ClassVariableOperatorWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(ClassVariableOperatorWriteNode) } - def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end - # Create a new ClassVariableOrWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(ClassVariableOrWriteNode) } - def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location); end - # Create a new ClassVariableReadNode node - sig { params(name: Symbol, location: Location).returns(ClassVariableReadNode) } - def ClassVariableReadNode(name, location); end - # Create a new ClassVariableTargetNode node - sig { params(name: Symbol, location: Location).returns(ClassVariableTargetNode) } - def ClassVariableTargetNode(name, location); end - # Create a new ClassVariableWriteNode node - sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: T.nilable(Location), location: Location).returns(ClassVariableWriteNode) } - def ClassVariableWriteNode(name, name_loc, value, operator_loc, location); end - # Create a new ConstantAndWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(ConstantAndWriteNode) } - def ConstantAndWriteNode(name, name_loc, operator_loc, value, location); end - # Create a new ConstantOperatorWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(ConstantOperatorWriteNode) } - def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end - # Create a new ConstantOrWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(ConstantOrWriteNode) } - def ConstantOrWriteNode(name, name_loc, operator_loc, value, location); end - # Create a new ConstantPathAndWriteNode node - sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).returns(ConstantPathAndWriteNode) } - def ConstantPathAndWriteNode(target, operator_loc, value, location); end - # Create a new ConstantPathNode node - sig { params(parent: T.nilable(Node), child: Node, delimiter_loc: Location, location: Location).returns(ConstantPathNode) } - def ConstantPathNode(parent, child, delimiter_loc, location); end - # Create a new ConstantPathOperatorWriteNode node - sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(ConstantPathOperatorWriteNode) } - def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location); end - # Create a new ConstantPathOrWriteNode node - sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).returns(ConstantPathOrWriteNode) } - def ConstantPathOrWriteNode(target, operator_loc, value, location); end - # Create a new ConstantPathTargetNode node - sig { params(parent: T.nilable(Node), child: Node, delimiter_loc: Location, location: Location).returns(ConstantPathTargetNode) } - def ConstantPathTargetNode(parent, child, delimiter_loc, location); end - # Create a new ConstantPathWriteNode node - sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).returns(ConstantPathWriteNode) } - def ConstantPathWriteNode(target, operator_loc, value, location); end - # Create a new ConstantReadNode node - sig { params(name: Symbol, location: Location).returns(ConstantReadNode) } - def ConstantReadNode(name, location); end - # Create a new ConstantTargetNode node - sig { params(name: Symbol, location: Location).returns(ConstantTargetNode) } - def ConstantTargetNode(name, location); end - # Create a new ConstantWriteNode node - sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location).returns(ConstantWriteNode) } - def ConstantWriteNode(name, name_loc, value, operator_loc, location); end - # Create a new DefNode node - sig { params(name: Symbol, name_loc: Location, receiver: T.nilable(Node), parameters: T.nilable(ParametersNode), body: T.nilable(Node), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: T.nilable(Location), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), equal_loc: T.nilable(Location), end_keyword_loc: T.nilable(Location), location: Location).returns(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(Location), value: Node, rparen_loc: T.nilable(Location), keyword_loc: Location, location: Location).returns(DefinedNode) } - def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location); end - # Create a new ElseNode node - sig { params(else_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: T.nilable(Location), location: Location).returns(ElseNode) } - def ElseNode(else_keyword_loc, statements, end_keyword_loc, location); end - # Create a new EmbeddedStatementsNode node - sig { params(opening_loc: Location, statements: T.nilable(StatementsNode), closing_loc: Location, location: Location).returns(EmbeddedStatementsNode) } - def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location); end - # Create a new EmbeddedVariableNode node - sig { params(operator_loc: Location, variable: Node, location: Location).returns(EmbeddedVariableNode) } - def EmbeddedVariableNode(operator_loc, variable, location); end - # Create a new EnsureNode node - sig { params(ensure_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: Location, location: Location).returns(EnsureNode) } - def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location); end - # Create a new FalseNode node - sig { params(location: Location).returns(FalseNode) } - def FalseNode(location); end - # Create a new FindPatternNode node - sig { params(constant: T.nilable(Node), left: Node, requireds: T::Array[Node], right: Node, opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(FindPatternNode) } - def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location); end - # Create a new FlipFlopNode node - sig { params(left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location, flags: Integer, location: Location).returns(FlipFlopNode) } - def FlipFlopNode(left, right, operator_loc, flags, location); end - # Create a new FloatNode node - sig { params(location: Location).returns(FloatNode) } - def FloatNode(location); end - # Create a new ForNode node - sig { params(index: Node, collection: Node, statements: T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: T.nilable(Location), end_keyword_loc: Location, location: Location).returns(ForNode) } - def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end - # Create a new ForwardingArgumentsNode node - sig { params(location: Location).returns(ForwardingArgumentsNode) } - def ForwardingArgumentsNode(location); end - # Create a new ForwardingParameterNode node - sig { params(location: Location).returns(ForwardingParameterNode) } - def ForwardingParameterNode(location); end - # Create a new ForwardingSuperNode node - sig { params(block: T.nilable(BlockNode), location: Location).returns(ForwardingSuperNode) } - def ForwardingSuperNode(block, location); end - # Create a new GlobalVariableAndWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(GlobalVariableAndWriteNode) } - def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location); end - # Create a new GlobalVariableOperatorWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(GlobalVariableOperatorWriteNode) } - def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end - # Create a new GlobalVariableOrWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(GlobalVariableOrWriteNode) } - def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location); end - # Create a new GlobalVariableReadNode node - sig { params(name: Symbol, location: Location).returns(GlobalVariableReadNode) } - def GlobalVariableReadNode(name, location); end - # Create a new GlobalVariableTargetNode node - sig { params(name: Symbol, location: Location).returns(GlobalVariableTargetNode) } - def GlobalVariableTargetNode(name, location); end - # Create a new GlobalVariableWriteNode node - sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location).returns(GlobalVariableWriteNode) } - def GlobalVariableWriteNode(name, name_loc, value, operator_loc, location); end - # Create a new HashNode node - sig { params(opening_loc: Location, elements: T::Array[Node], closing_loc: Location, location: Location).returns(HashNode) } - def HashNode(opening_loc, elements, closing_loc, location); end - # Create a new HashPatternNode node - sig { params(constant: T.nilable(Node), elements: T::Array[Node], rest: T.nilable(Node), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(HashPatternNode) } - def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location); end - # Create a new IfNode node - sig { params(if_keyword_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), consequent: T.nilable(Node), end_keyword_loc: T.nilable(Location), location: Location).returns(IfNode) } - def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end - # Create a new ImaginaryNode node - sig { params(numeric: Node, location: Location).returns(ImaginaryNode) } - def ImaginaryNode(numeric, location); end - # Create a new ImplicitNode node - sig { params(value: Node, location: Location).returns(ImplicitNode) } - def ImplicitNode(value, location); end - # Create a new InNode node - sig { params(pattern: Node, statements: T.nilable(StatementsNode), in_loc: Location, then_loc: T.nilable(Location), location: Location).returns(InNode) } - def InNode(pattern, statements, in_loc, then_loc, location); end - # Create a new IndexAndWriteNode node - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(Node), flags: Integer, operator_loc: Location, value: Node, location: Location).returns(IndexAndWriteNode) } - def IndexAndWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location); end - # Create a new IndexOperatorWriteNode node - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(Node), flags: Integer, operator: Symbol, operator_loc: Location, value: Node, location: Location).returns(IndexOperatorWriteNode) } - def IndexOperatorWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location); end - # Create a new IndexOrWriteNode node - sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(Node), flags: Integer, operator_loc: Location, value: Node, location: Location).returns(IndexOrWriteNode) } - def IndexOrWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location); end - # Create a new InstanceVariableAndWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(InstanceVariableAndWriteNode) } - def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location); end - # Create a new InstanceVariableOperatorWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(InstanceVariableOperatorWriteNode) } - def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end - # Create a new InstanceVariableOrWriteNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(InstanceVariableOrWriteNode) } - def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location); end - # Create a new InstanceVariableReadNode node - sig { params(name: Symbol, location: Location).returns(InstanceVariableReadNode) } - def InstanceVariableReadNode(name, location); end - # Create a new InstanceVariableTargetNode node - sig { params(name: Symbol, location: Location).returns(InstanceVariableTargetNode) } - def InstanceVariableTargetNode(name, location); end - # Create a new InstanceVariableWriteNode node - sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location).returns(InstanceVariableWriteNode) } - def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location); end - # Create a new IntegerNode node - sig { params(flags: Integer, location: Location).returns(IntegerNode) } - def IntegerNode(flags, location); end - # Create a new InterpolatedMatchLastLineNode node - sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, flags: Integer, location: Location).returns(InterpolatedMatchLastLineNode) } - def InterpolatedMatchLastLineNode(opening_loc, parts, closing_loc, flags, location); end - # Create a new InterpolatedRegularExpressionNode node - sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, flags: Integer, location: Location).returns(InterpolatedRegularExpressionNode) } - def InterpolatedRegularExpressionNode(opening_loc, parts, closing_loc, flags, location); end - # Create a new InterpolatedStringNode node - sig { params(opening_loc: T.nilable(Location), parts: T::Array[Node], closing_loc: T.nilable(Location), location: Location).returns(InterpolatedStringNode) } - def InterpolatedStringNode(opening_loc, parts, closing_loc, location); end - # Create a new InterpolatedSymbolNode node - sig { params(opening_loc: T.nilable(Location), parts: T::Array[Node], closing_loc: T.nilable(Location), location: Location).returns(InterpolatedSymbolNode) } - def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location); end - # Create a new InterpolatedXStringNode node - sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, location: Location).returns(InterpolatedXStringNode) } - def InterpolatedXStringNode(opening_loc, parts, closing_loc, location); end - # Create a new KeywordHashNode node - sig { params(elements: T::Array[Node], location: Location).returns(KeywordHashNode) } - def KeywordHashNode(elements, location); end - # Create a new KeywordRestParameterNode node - sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location, location: Location).returns(KeywordRestParameterNode) } - def KeywordRestParameterNode(name, name_loc, operator_loc, location); end - # Create a new LambdaNode node - sig { params(locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: T.nilable(BlockParametersNode), body: T.nilable(Node), location: Location).returns(LambdaNode) } - def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end - # Create a new LocalVariableAndWriteNode node - sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location).returns(LocalVariableAndWriteNode) } - def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location); end - # Create a new LocalVariableOperatorWriteNode node - sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location).returns(LocalVariableOperatorWriteNode) } - def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location); end - # Create a new LocalVariableOrWriteNode node - sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location).returns(LocalVariableOrWriteNode) } - def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location); end - # Create a new LocalVariableReadNode node - sig { params(name: Symbol, depth: Integer, location: Location).returns(LocalVariableReadNode) } - def LocalVariableReadNode(name, depth, location); end - # Create a new LocalVariableTargetNode node - sig { params(name: Symbol, depth: Integer, location: Location).returns(LocalVariableTargetNode) } - def LocalVariableTargetNode(name, depth, location); end - # Create a new LocalVariableWriteNode node - sig { params(name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location).returns(LocalVariableWriteNode) } - def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location); end - # Create a new MatchLastLineNode node - sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location).returns(MatchLastLineNode) } - def MatchLastLineNode(opening_loc, content_loc, closing_loc, unescaped, flags, location); end - # Create a new MatchPredicateNode node - sig { params(value: Node, pattern: Node, operator_loc: Location, location: Location).returns(MatchPredicateNode) } - def MatchPredicateNode(value, pattern, operator_loc, location); end - # Create a new MatchRequiredNode node - sig { params(value: Node, pattern: Node, operator_loc: Location, location: Location).returns(MatchRequiredNode) } - def MatchRequiredNode(value, pattern, operator_loc, location); end - # Create a new MatchWriteNode node - sig { params(call: CallNode, locals: T::Array[Symbol], location: Location).returns(MatchWriteNode) } - def MatchWriteNode(call, locals, location); end - # Create a new MissingNode node - sig { params(location: Location).returns(MissingNode) } - def MissingNode(location); end - # Create a new ModuleNode node - sig { params(locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: T.nilable(Node), end_keyword_loc: Location, name: Symbol, location: Location).returns(ModuleNode) } - def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end - # Create a new MultiTargetNode node - sig { params(lefts: T::Array[Node], rest: T.nilable(Node), rights: T::Array[Node], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), location: Location).returns(MultiTargetNode) } - def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, location); end - # Create a new MultiWriteNode node - sig { params(lefts: T::Array[Node], rest: T.nilable(Node), rights: T::Array[Node], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), operator_loc: Location, value: Node, location: Location).returns(MultiWriteNode) } - def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end - # Create a new NextNode node - sig { params(arguments: T.nilable(ArgumentsNode), keyword_loc: Location, location: Location).returns(NextNode) } - def NextNode(arguments, keyword_loc, location); end - # Create a new NilNode node - sig { params(location: Location).returns(NilNode) } - def NilNode(location); end - # Create a new NoKeywordsParameterNode node - sig { params(operator_loc: Location, keyword_loc: Location, location: Location).returns(NoKeywordsParameterNode) } - def NoKeywordsParameterNode(operator_loc, keyword_loc, location); end - # Create a new NumberedReferenceReadNode node - sig { params(number: Integer, location: Location).returns(NumberedReferenceReadNode) } - def NumberedReferenceReadNode(number, location); end - # Create a new OptionalKeywordParameterNode node - sig { params(name: Symbol, name_loc: Location, value: Node, location: Location).returns(OptionalKeywordParameterNode) } - def OptionalKeywordParameterNode(name, name_loc, value, location); end - # Create a new OptionalParameterNode node - sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(OptionalParameterNode) } - def OptionalParameterNode(name, name_loc, operator_loc, value, location); end - # Create a new OrNode node - sig { params(left: Node, right: Node, operator_loc: Location, location: Location).returns(OrNode) } - def OrNode(left, right, operator_loc, location); end - # Create a new ParametersNode node - sig { params(requireds: T::Array[Node], optionals: T::Array[Node], rest: T.nilable(RestParameterNode), posts: T::Array[Node], keywords: T::Array[Node], keyword_rest: T.nilable(Node), block: T.nilable(BlockParameterNode), location: Location).returns(ParametersNode) } - def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end - # Create a new ParenthesesNode node - sig { params(body: T.nilable(Node), opening_loc: Location, closing_loc: Location, location: Location).returns(ParenthesesNode) } - def ParenthesesNode(body, opening_loc, closing_loc, location); end - # Create a new PinnedExpressionNode node - sig { params(expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location).returns(PinnedExpressionNode) } - def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location); end - # Create a new PinnedVariableNode node - sig { params(variable: Node, operator_loc: Location, location: Location).returns(PinnedVariableNode) } - def PinnedVariableNode(variable, operator_loc, location); end - # Create a new PostExecutionNode node - sig { params(statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location).returns(PostExecutionNode) } - def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location); end - # Create a new PreExecutionNode node - sig { params(statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location).returns(PreExecutionNode) } - def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location); end - # Create a new ProgramNode node - sig { params(locals: T::Array[Symbol], statements: StatementsNode, location: Location).returns(ProgramNode) } - def ProgramNode(locals, statements, location); end - # Create a new RangeNode node - sig { params(left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location, flags: Integer, location: Location).returns(RangeNode) } - def RangeNode(left, right, operator_loc, flags, location); end - # Create a new RationalNode node - sig { params(numeric: Node, location: Location).returns(RationalNode) } - def RationalNode(numeric, location); end - # Create a new RedoNode node - sig { params(location: Location).returns(RedoNode) } - def RedoNode(location); end - # Create a new RegularExpressionNode node - sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location).returns(RegularExpressionNode) } - def RegularExpressionNode(opening_loc, content_loc, closing_loc, unescaped, flags, location); end - # Create a new RequiredKeywordParameterNode node - sig { params(name: Symbol, name_loc: Location, location: Location).returns(RequiredKeywordParameterNode) } - def RequiredKeywordParameterNode(name, name_loc, location); end - # Create a new RequiredParameterNode node - sig { params(name: Symbol, location: Location).returns(RequiredParameterNode) } - def RequiredParameterNode(name, location); end - # Create a new RescueModifierNode node - sig { params(expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location).returns(RescueModifierNode) } - def RescueModifierNode(expression, keyword_loc, rescue_expression, location); end - # Create a new RescueNode node - sig { params(keyword_loc: Location, exceptions: T::Array[Node], operator_loc: T.nilable(Location), reference: T.nilable(Node), statements: T.nilable(StatementsNode), consequent: T.nilable(RescueNode), location: Location).returns(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(Location), operator_loc: Location, location: Location).returns(RestParameterNode) } - def RestParameterNode(name, name_loc, operator_loc, location); end - # Create a new RetryNode node - sig { params(location: Location).returns(RetryNode) } - def RetryNode(location); end - # Create a new ReturnNode node - sig { params(keyword_loc: Location, arguments: T.nilable(ArgumentsNode), location: Location).returns(ReturnNode) } - def ReturnNode(keyword_loc, arguments, location); end - # Create a new SelfNode node - sig { params(location: Location).returns(SelfNode) } - def SelfNode(location); end - # Create a new SingletonClassNode node - sig { params(locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: T.nilable(Node), end_keyword_loc: Location, location: Location).returns(SingletonClassNode) } - def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end - # Create a new SourceEncodingNode node - sig { params(location: Location).returns(SourceEncodingNode) } - def SourceEncodingNode(location); end - # Create a new SourceFileNode node - sig { params(filepath: String, location: Location).returns(SourceFileNode) } - def SourceFileNode(filepath, location); end - # Create a new SourceLineNode node - sig { params(location: Location).returns(SourceLineNode) } - def SourceLineNode(location); end - # Create a new SplatNode node - sig { params(operator_loc: Location, expression: T.nilable(Node), location: Location).returns(SplatNode) } - def SplatNode(operator_loc, expression, location); end - # Create a new StatementsNode node - sig { params(body: T::Array[Node], location: Location).returns(StatementsNode) } - def StatementsNode(body, location); end - # Create a new StringConcatNode node - sig { params(left: Node, right: Node, location: Location).returns(StringConcatNode) } - def StringConcatNode(left, right, location); end - # Create a new StringNode node - sig { params(flags: Integer, opening_loc: T.nilable(Location), content_loc: Location, closing_loc: T.nilable(Location), unescaped: String, location: Location).returns(StringNode) } - def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location); end - # Create a new SuperNode node - sig { params(keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), block: T.nilable(Node), location: Location).returns(SuperNode) } - def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end - # Create a new SymbolNode node - sig { params(opening_loc: T.nilable(Location), value_loc: T.nilable(Location), closing_loc: T.nilable(Location), unescaped: String, location: Location).returns(SymbolNode) } - def SymbolNode(opening_loc, value_loc, closing_loc, unescaped, location); end - # Create a new TrueNode node - sig { params(location: Location).returns(TrueNode) } - def TrueNode(location); end - # Create a new UndefNode node - sig { params(names: T::Array[Node], keyword_loc: Location, location: Location).returns(UndefNode) } - def UndefNode(names, keyword_loc, location); end - # Create a new UnlessNode node - sig { params(keyword_loc: Location, predicate: Node, statements: T.nilable(StatementsNode), consequent: T.nilable(ElseNode), end_keyword_loc: T.nilable(Location), location: Location).returns(UnlessNode) } - def UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end - # Create a new UntilNode node - sig { params(keyword_loc: Location, closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), flags: Integer, location: Location).returns(UntilNode) } - def UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location); end - # Create a new WhenNode node - sig { params(keyword_loc: Location, conditions: T::Array[Node], statements: T.nilable(StatementsNode), location: Location).returns(WhenNode) } - def WhenNode(keyword_loc, conditions, statements, location); end - # Create a new WhileNode node - sig { params(keyword_loc: Location, closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), flags: Integer, location: Location).returns(WhileNode) } - def WhileNode(keyword_loc, closing_loc, predicate, statements, flags, location); end - # Create a new XStringNode node - sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location).returns(XStringNode) } - def XStringNode(opening_loc, content_loc, closing_loc, unescaped, location); end - # Create a new YieldNode node - sig { params(keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), location: Location).returns(YieldNode) } - def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location); end - end + # Create a new AliasGlobalVariableNode node + sig { params(new_name: Prism::Node, old_name: Prism::Node, keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::AliasGlobalVariableNode) } + def AliasGlobalVariableNode(new_name, old_name, keyword_loc, location); end + # Create a new AliasMethodNode node + sig { params(new_name: Prism::Node, old_name: Prism::Node, keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::AliasMethodNode) } + def AliasMethodNode(new_name, old_name, keyword_loc, location); end + # Create a new AlternationPatternNode node + sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::AlternationPatternNode) } + 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 + # 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 + # 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) } + 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) } + def AssocSplatNode(value, operator_loc, location); end + # Create a new BackReferenceReadNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::BackReferenceReadNode) } + def BackReferenceReadNode(name, location); end + # Create a new BeginNode node + sig { params(begin_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), rescue_clause: T.nilable(Prism::RescueNode), else_clause: T.nilable(Prism::ElseNode), ensure_clause: T.nilable(Prism::EnsureNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::BeginNode) } + def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end + # Create a new BlockArgumentNode node + 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 + # 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 + # 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 + # 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 + # 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 + # 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 + # 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 CaseNode node + sig { params(predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::Node], consequent: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::CaseNode) } + def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end + # Create a new ClassNode node + sig { params(locals: T::Array[Symbol], class_keyword_loc: Prism::Location, constant_path: Prism::Node, inheritance_operator_loc: T.nilable(Prism::Location), superclass: T.nilable(Prism::Node), body: T.nilable(Prism::Node), end_keyword_loc: Prism::Location, name: Symbol, location: Prism::Location).returns(Prism::ClassNode) } + def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end + # Create a new ClassVariableAndWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::ClassVariableAndWriteNode) } + def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location); end + # Create a new ClassVariableOperatorWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::ClassVariableOperatorWriteNode) } + def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end + # Create a new ClassVariableOrWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::ClassVariableOrWriteNode) } + def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location); end + # Create a new ClassVariableReadNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::ClassVariableReadNode) } + def ClassVariableReadNode(name, location); end + # Create a new ClassVariableTargetNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::ClassVariableTargetNode) } + def ClassVariableTargetNode(name, location); end + # Create a new ClassVariableWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, operator_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::ClassVariableWriteNode) } + def ClassVariableWriteNode(name, name_loc, value, operator_loc, location); end + # Create a new ConstantAndWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::ConstantAndWriteNode) } + def ConstantAndWriteNode(name, name_loc, operator_loc, value, location); end + # Create a new ConstantOperatorWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::ConstantOperatorWriteNode) } + def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end + # Create a new ConstantOrWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::ConstantOrWriteNode) } + def ConstantOrWriteNode(name, name_loc, operator_loc, value, location); end + # Create a new ConstantPathAndWriteNode node + sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::ConstantPathAndWriteNode) } + def ConstantPathAndWriteNode(target, operator_loc, value, location); end + # Create a new ConstantPathNode node + sig { params(parent: T.nilable(Prism::Node), child: Prism::Node, delimiter_loc: Prism::Location, location: Prism::Location).returns(Prism::ConstantPathNode) } + def ConstantPathNode(parent, child, delimiter_loc, location); end + # Create a new ConstantPathOperatorWriteNode node + sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::ConstantPathOperatorWriteNode) } + def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location); end + # Create a new ConstantPathOrWriteNode node + sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::ConstantPathOrWriteNode) } + def ConstantPathOrWriteNode(target, operator_loc, value, location); end + # Create a new ConstantPathTargetNode node + sig { params(parent: T.nilable(Prism::Node), child: Prism::Node, delimiter_loc: Prism::Location, location: Prism::Location).returns(Prism::ConstantPathTargetNode) } + def ConstantPathTargetNode(parent, child, delimiter_loc, location); end + # Create a new ConstantPathWriteNode node + sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::ConstantPathWriteNode) } + def ConstantPathWriteNode(target, operator_loc, value, location); end + # Create a new ConstantReadNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::ConstantReadNode) } + def ConstantReadNode(name, location); end + # Create a new ConstantTargetNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::ConstantTargetNode) } + 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 + # 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) } + def ElseNode(else_keyword_loc, statements, end_keyword_loc, location); end + # Create a new EmbeddedStatementsNode node + sig { params(opening_loc: Prism::Location, statements: T.nilable(Prism::StatementsNode), closing_loc: Prism::Location, location: Prism::Location).returns(Prism::EmbeddedStatementsNode) } + def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location); end + # Create a new EmbeddedVariableNode node + sig { params(operator_loc: Prism::Location, variable: Prism::Node, location: Prism::Location).returns(Prism::EmbeddedVariableNode) } + def EmbeddedVariableNode(operator_loc, variable, location); end + # Create a new EnsureNode node + sig { params(ensure_keyword_loc: Prism::Location, statements: T.nilable(Prism::StatementsNode), end_keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::EnsureNode) } + def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location); end + # Create a new FalseNode node + sig { params(location: Prism::Location).returns(Prism::FalseNode) } + 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 + # 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) } + def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end + # Create a new ForwardingArgumentsNode node + sig { params(location: Prism::Location).returns(Prism::ForwardingArgumentsNode) } + def ForwardingArgumentsNode(location); end + # Create a new ForwardingParameterNode node + sig { params(location: Prism::Location).returns(Prism::ForwardingParameterNode) } + def ForwardingParameterNode(location); end + # Create a new ForwardingSuperNode node + sig { params(block: T.nilable(Prism::BlockNode), location: Prism::Location).returns(Prism::ForwardingSuperNode) } + def ForwardingSuperNode(block, location); end + # Create a new GlobalVariableAndWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::GlobalVariableAndWriteNode) } + def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location); end + # Create a new GlobalVariableOperatorWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::GlobalVariableOperatorWriteNode) } + def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end + # Create a new GlobalVariableOrWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::GlobalVariableOrWriteNode) } + def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location); end + # Create a new GlobalVariableReadNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::GlobalVariableReadNode) } + def GlobalVariableReadNode(name, location); end + # Create a new GlobalVariableTargetNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::GlobalVariableTargetNode) } + def GlobalVariableTargetNode(name, location); end + # Create a new GlobalVariableWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::GlobalVariableWriteNode) } + def GlobalVariableWriteNode(name, name_loc, value, operator_loc, location); end + # Create a new HashNode node + sig { params(opening_loc: Prism::Location, elements: T::Array[Prism::Node], closing_loc: Prism::Location, location: Prism::Location).returns(Prism::HashNode) } + def HashNode(opening_loc, elements, closing_loc, location); end + # Create a new HashPatternNode node + sig { params(constant: T.nilable(Prism::Node), elements: T::Array[Prism::Node], rest: T.nilable(Prism::Node), opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::HashPatternNode) } + def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location); end + # Create a new IfNode node + sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::IfNode) } + def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + # Create a new ImaginaryNode node + sig { params(numeric: Prism::Node, location: Prism::Location).returns(Prism::ImaginaryNode) } + def ImaginaryNode(numeric, location); end + # Create a new ImplicitNode node + sig { params(value: Prism::Node, location: Prism::Location).returns(Prism::ImplicitNode) } + def ImplicitNode(value, location); end + # Create a new 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 + # 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 + # 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 + # 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) } + def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end + # Create a new InstanceVariableOrWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::InstanceVariableOrWriteNode) } + def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location); end + # Create a new InstanceVariableReadNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::InstanceVariableReadNode) } + def InstanceVariableReadNode(name, location); end + # Create a new InstanceVariableTargetNode node + sig { params(name: Symbol, location: Prism::Location).returns(Prism::InstanceVariableTargetNode) } + def InstanceVariableTargetNode(name, location); end + # Create a new InstanceVariableWriteNode node + sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::InstanceVariableWriteNode) } + 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 + # 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 + # 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 + # 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 + # 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) } + def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location); end + # Create a new LocalVariableOrWriteNode node + sig { params(name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableOrWriteNode) } + def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location); end + # Create a new LocalVariableReadNode node + sig { params(name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableReadNode) } + def LocalVariableReadNode(name, depth, location); end + # Create a new LocalVariableTargetNode node + sig { params(name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableTargetNode) } + 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 + # 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) } + def MatchRequiredNode(value, pattern, operator_loc, location); end + # Create a new MatchWriteNode node + sig { params(call: Prism::CallNode, locals: T::Array[Symbol], location: Prism::Location).returns(Prism::MatchWriteNode) } + def MatchWriteNode(call, locals, location); end + # Create a new MissingNode node + sig { params(location: Prism::Location).returns(Prism::MissingNode) } + def MissingNode(location); end + # Create a new ModuleNode node + sig { params(locals: T::Array[Symbol], module_keyword_loc: Prism::Location, constant_path: Prism::Node, body: T.nilable(Prism::Node), end_keyword_loc: Prism::Location, name: Symbol, location: Prism::Location).returns(Prism::ModuleNode) } + def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end + # Create a new MultiTargetNode node + sig { params(lefts: T::Array[Prism::Node], rest: T.nilable(Prism::Node), rights: T::Array[Prism::Node], lparen_loc: T.nilable(Prism::Location), rparen_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::MultiTargetNode) } + def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, location); end + # Create a new MultiWriteNode node + sig { params(lefts: T::Array[Prism::Node], rest: T.nilable(Prism::Node), rights: T::Array[Prism::Node], lparen_loc: T.nilable(Prism::Location), rparen_loc: T.nilable(Prism::Location), operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::MultiWriteNode) } + def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end + # Create a new NextNode node + sig { params(arguments: T.nilable(Prism::ArgumentsNode), keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::NextNode) } + def NextNode(arguments, keyword_loc, location); end + # Create a new NilNode node + 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 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) } + def OptionalKeywordParameterNode(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 + # 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) } + 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 + sig { params(expression: Prism::Node, operator_loc: Prism::Location, lparen_loc: Prism::Location, rparen_loc: Prism::Location, location: Prism::Location).returns(Prism::PinnedExpressionNode) } + def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location); end + # Create a new PinnedVariableNode node + sig { params(variable: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::PinnedVariableNode) } + def PinnedVariableNode(variable, operator_loc, location); end + # Create a new PostExecutionNode node + sig { params(statements: T.nilable(Prism::StatementsNode), keyword_loc: Prism::Location, opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).returns(Prism::PostExecutionNode) } + def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location); end + # Create a new PreExecutionNode node + sig { params(statements: T.nilable(Prism::StatementsNode), keyword_loc: Prism::Location, opening_loc: Prism::Location, closing_loc: Prism::Location, location: Prism::Location).returns(Prism::PreExecutionNode) } + 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 + # 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 + # 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) } + def RequiredParameterNode(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 + # Create a new RescueNode node + 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 + # Create a new RetryNode node + sig { params(location: Prism::Location).returns(Prism::RetryNode) } + def RetryNode(location); end + # Create a new ReturnNode node + sig { params(keyword_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), location: Prism::Location).returns(Prism::ReturnNode) } + def ReturnNode(keyword_loc, arguments, location); end + # Create a new SelfNode node + sig { params(location: Prism::Location).returns(Prism::SelfNode) } + def SelfNode(location); end + # Create a new SingletonClassNode node + sig { params(locals: T::Array[Symbol], class_keyword_loc: Prism::Location, operator_loc: Prism::Location, expression: Prism::Node, body: T.nilable(Prism::Node), end_keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::SingletonClassNode) } + def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end + # Create a new SourceEncodingNode node + sig { params(location: Prism::Location).returns(Prism::SourceEncodingNode) } + def SourceEncodingNode(location); end + # Create a new SourceFileNode node + sig { params(filepath: String, location: Prism::Location).returns(Prism::SourceFileNode) } + def SourceFileNode(filepath, location); end + # Create a new SourceLineNode node + sig { params(location: Prism::Location).returns(Prism::SourceLineNode) } + def SourceLineNode(location); end + # Create a new SplatNode node + sig { params(operator_loc: Prism::Location, expression: T.nilable(Prism::Node), location: Prism::Location).returns(Prism::SplatNode) } + def SplatNode(operator_loc, expression, location); end + # Create a new StatementsNode node + sig { params(body: T::Array[Prism::Node], location: Prism::Location).returns(Prism::StatementsNode) } + def StatementsNode(body, location); end + # Create a new StringConcatNode node + sig { params(left: Prism::Node, right: Prism::Node, location: Prism::Location).returns(Prism::StringConcatNode) } + def StringConcatNode(left, right, location); end + # Create a new StringNode node + sig { params(flags: Integer, opening_loc: T.nilable(Prism::Location), content_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), unescaped: String, location: Prism::Location).returns(Prism::StringNode) } + def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location); end + # 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 + # 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, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::UnlessNode) } + def UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + # 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 + # 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 + # 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 + # 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