# typed: strict

begin

This file is generated by the templates/template.rb script and should not be modified manually. See templates/rbi/prism/node.rbi.erb if you are looking to modify the template

end

class Prism::Node

abstract!

sig { returns(Prism::Source) }
def source; end

sig { returns(Integer) }
def node_id; end

sig { returns(Prism::Location) }
def location; end

sig{ returns(Integer) }
def flags; end

sig { returns(T::Boolean) }
def newline?; end

sig { returns(T::Boolean) }
def static_literal?; end

sig { returns(Integer) }
def start_offset; end

sig { returns(Integer) }
def end_offset; end

sig { returns(T::Array[String]) }
def source_lines; end

sig { returns(T::Array[String]) }
def script_lines; end

sig { returns(String) }
def slice; end

sig { returns(String) }
def slice_lines; end

sig { params(q: T.untyped).void }
def pretty_print(q); end

sig { returns(String) }
def to_dot; end

sig { params(line: Integer, column: Integer).returns(T::Array[Prism::Node]) }
def tunnel(line, column); end

sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T.nilable(Prism::Node)) }
def breadth_first_search(&block); end

sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T::Array[Prism::Node]) }
def breadth_first_search_all(&block); end

sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { abstract.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { abstract.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { abstract.returns(Symbol) }
def type; end

sig { abstract.returns(String) }
def inspect; end

end

# Represents the use of the alias keyword to alias a global variable. # # alias $foo $bar # ^^^^^^^^^^^^^^^ class Prism::AliasGlobalVariableNode < Prism::Node

sig { returns(T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)) }
def new_name; end

sig { returns(T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode)) }
def old_name; end

sig { returns(Prism::Location) }
def keyword_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, new_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode), old_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode), keyword_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, new_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode), old_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode), keyword_loc: Prism::Location).returns(Prism::AliasGlobalVariableNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, new_name: self.new_name, old_name: self.old_name, keyword_loc: self.keyword_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def keyword; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents the use of the alias keyword to alias a method. # # alias foo bar # ^^^^^^^^^^^^^ class Prism::AliasMethodNode < Prism::Node

sig { returns(T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)) }
def new_name; end

sig { returns(T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode)) }
def old_name; end

sig { returns(Prism::Location) }
def keyword_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, new_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode), old_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode), keyword_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, new_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode), old_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode), keyword_loc: Prism::Location).returns(Prism::AliasMethodNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, new_name: self.new_name, old_name: self.old_name, keyword_loc: self.keyword_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def keyword; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents an alternation pattern in pattern matching. # # foo => bar | baz # ^^^^^^^^^ class Prism::AlternationPatternNode < Prism::Node

sig { returns(Prism::Node) }
def left; end

sig { returns(Prism::Node) }
def right; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, left, right, operator_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location).returns(Prism::AlternationPatternNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, left: self.left, right: self.right, operator_loc: self.operator_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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(Prism::Node) }
def right; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, left, right, operator_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location).returns(Prism::AndNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, left: self.left, right: self.right, operator_loc: self.operator_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents a set of arguments to a method or a keyword. # # return foo, bar, baz # ^^^^^^^^^^^^^ class Prism::ArgumentsNode < Prism::Node

sig { returns(T::Boolean) }
def contains_forwarding?; end

sig { returns(T::Boolean) }
def contains_keywords?; end

sig { returns(T::Boolean) }
def contains_keyword_splat?; end

sig { returns(T::Boolean) }
def contains_splat?; end

sig { returns(T::Boolean) }
def contains_multiple_splats?; end

sig { returns(T::Array[Prism::Node]) }
def arguments; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, arguments: T::Array[Prism::Node]).void }
def initialize(source, node_id, location, flags, arguments); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, arguments: T::Array[Prism::Node]).returns(Prism::ArgumentsNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, arguments: self.arguments); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; 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 Prism::ArrayNode < Prism::Node

sig { returns(T::Boolean) }
def contains_splat?; end

sig { returns(T::Array[Prism::Node]) }
def elements; end

sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end

sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, elements: T::Array[Prism::Node], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location)).void }
def initialize(source, node_id, location, flags, elements, opening_loc, closing_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, elements: T::Array[Prism::Node], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location)).returns(Prism::ArrayNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, elements: self.elements, opening_loc: self.opening_loc, closing_loc: self.closing_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def opening; end

sig { returns(T.nilable(String)) }
def closing; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents an array pattern in pattern matching. # # foo in 1, 2 # ^^^^^^^^^^^ # # foo in [1, 2] # ^^^^^^^^^^^^^ # # foo in *bar # ^^^^^^^^^^^ # # foo in Bar[] # ^^^^^^^^^^^^ # # foo in Bar[1, 2, 3] # ^^^^^^^^^^^^^^^^^^^ class Prism::ArrayPatternNode < Prism::Node

sig { returns(T.nilable(T.any(Prism::ConstantPathNode, Prism::ConstantReadNode))) }
def constant; end

sig { returns(T::Array[Prism::Node]) }
def requireds; end

sig { returns(T.nilable(Prism::Node)) }
def rest; end

sig { returns(T::Array[Prism::Node]) }
def posts; end

sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end

sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, constant: T.nilable(T.any(Prism::ConstantPathNode, Prism::ConstantReadNode)), 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)).void }
def initialize(source, node_id, location, flags, constant, requireds, rest, posts, opening_loc, closing_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, constant: T.nilable(T.any(Prism::ConstantPathNode, Prism::ConstantReadNode)), 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)).returns(Prism::ArrayPatternNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, requireds: self.requireds, rest: self.rest, posts: self.posts, opening_loc: self.opening_loc, closing_loc: self.closing_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def opening; end

sig { returns(T.nilable(String)) }
def closing; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents a hash key/value pair. # # { a => b } # ^^^^^^ class Prism::AssocNode < Prism::Node

sig { returns(Prism::Node) }
def key; end

sig { returns(Prism::Node) }
def value; end

sig { returns(T.nilable(Prism::Location)) }
def operator_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, key: Prism::Node, value: Prism::Node, operator_loc: T.nilable(Prism::Location)).void }
def initialize(source, node_id, location, flags, key, value, operator_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, key: Prism::Node, value: Prism::Node, operator_loc: T.nilable(Prism::Location)).returns(Prism::AssocNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, key: self.key, value: self.value, operator_loc: self.operator_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents a splat in a hash literal. # # { **foo } # ^^^^^ class Prism::AssocSplatNode < Prism::Node

sig { returns(T.nilable(Prism::Node)) }
def value; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, value: T.nilable(Prism::Node), operator_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, value, operator_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, value: T.nilable(Prism::Node), operator_loc: Prism::Location).returns(Prism::AssocSplatNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, value: self.value, operator_loc: self.operator_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents reading a reference to a field in the previous match. # # $‘ # ^^ class Prism::BackReferenceReadNode < Prism::Node

sig { returns(Symbol) }
def name; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
def initialize(source, node_id, location, flags, name); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).returns(Prism::BackReferenceReadNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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(Prism::StatementsNode)) }
def statements; end

sig { returns(T.nilable(Prism::RescueNode)) }
def rescue_clause; end

sig { returns(T.nilable(Prism::ElseNode)) }
def else_clause; end

sig { returns(T.nilable(Prism::EnsureNode)) }
def ensure_clause; end

sig { returns(T.nilable(Prism::Location)) }
def end_keyword_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, 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)).void }
def initialize(source, node_id, location, flags, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, 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)).returns(Prism::BeginNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, begin_keyword_loc: self.begin_keyword_loc, statements: self.statements, rescue_clause: self.rescue_clause, else_clause: self.else_clause, ensure_clause: self.ensure_clause, end_keyword_loc: self.end_keyword_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def begin_keyword; end

sig { returns(T.nilable(String)) }
def end_keyword; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents a block argument using ‘&`. # # bar(&args) # ^^^^^^^^^^ class Prism::BlockArgumentNode < Prism::Node

sig { returns(T.nilable(Prism::Node)) }
def expression; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, expression: T.nilable(Prism::Node), operator_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, expression, operator_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, expression: T.nilable(Prism::Node), operator_loc: Prism::Location).returns(Prism::BlockArgumentNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, expression: self.expression, operator_loc: self.operator_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents a block local variable. # # a { |; b| } # ^ class Prism::BlockLocalVariableNode < Prism::Node

sig { returns(T::Boolean) }
def repeated_parameter?; end

sig { returns(Symbol) }
def name; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
def initialize(source, node_id, location, flags, name); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).returns(Prism::BlockLocalVariableNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode))) }
def parameters; end

sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) }
def body; end

sig { returns(Prism::Location) }
def opening_loc; end

sig { returns(Prism::Location) }
def closing_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, locals: T::Array[Symbol], parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)), body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)), opening_loc: Prism::Location, closing_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, locals, parameters, body, opening_loc, closing_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, locals: T::Array[Symbol], parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)), body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)), opening_loc: Prism::Location, closing_loc: Prism::Location).returns(Prism::BlockNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, locals: self.locals, parameters: self.parameters, body: self.body, opening_loc: self.opening_loc, closing_loc: self.closing_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def opening; end

sig { returns(String) }
def closing; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents a block parameter of a method, block, or lambda definition. # # def a(&b) # ^^ # end class Prism::BlockParameterNode < Prism::Node

sig { returns(T::Boolean) }
def repeated_parameter?; end

sig { returns(T.nilable(Symbol)) }
def name; end

sig { returns(T.nilable(Prism::Location)) }
def name_loc; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Prism::Location), operator_loc: Prism::Location).returns(Prism::BlockParameterNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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[Prism::BlockLocalVariableNode]) }
def locals; end

sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end

sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, parameters: T.nilable(Prism::ParametersNode), locals: T::Array[Prism::BlockLocalVariableNode], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location)).void }
def initialize(source, node_id, location, flags, parameters, locals, opening_loc, closing_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, parameters: T.nilable(Prism::ParametersNode), locals: T::Array[Prism::BlockLocalVariableNode], opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location)).returns(Prism::BlockParametersNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, parameters: self.parameters, locals: self.locals, opening_loc: self.opening_loc, closing_loc: self.closing_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def opening; end

sig { returns(T.nilable(String)) }
def closing; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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(Prism::Location) }
def keyword_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, arguments: T.nilable(Prism::ArgumentsNode), keyword_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, arguments, keyword_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, arguments: T.nilable(Prism::ArgumentsNode), keyword_loc: Prism::Location).returns(Prism::BreakNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, arguments: self.arguments, keyword_loc: self.keyword_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def keyword; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents the use of the ‘&&=` operator on a call. # # foo.bar &&= value # ^^^^^^^^^^^^^^^^^ class Prism::CallAndWriteNode < Prism::Node

sig { returns(T::Boolean) }
def safe_navigation?; end

sig { returns(T::Boolean) }
def variable_call?; end

sig { returns(T::Boolean) }
def attribute_write?; end

sig { returns(T::Boolean) }
def ignore_visibility?; end

sig { returns(T.nilable(Prism::Node)) }
def receiver; end

sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end

sig { returns(T.nilable(Prism::Location)) }
def message_loc; end

sig { returns(Symbol) }
def read_name; end

sig { returns(Symbol) }
def write_name; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { returns(Prism::Node) }
def value; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node).void }
def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node).returns(Prism::CallAndWriteNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, message_loc: self.message_loc, read_name: self.read_name, write_name: self.write_name, operator_loc: self.operator_loc, value: self.value); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def call_operator; end

sig { returns(T.nilable(String)) }
def message; end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; 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 Prism::CallNode < Prism::Node

sig { returns(T::Boolean) }
def safe_navigation?; end

sig { returns(T::Boolean) }
def variable_call?; end

sig { returns(T::Boolean) }
def attribute_write?; end

sig { returns(T::Boolean) }
def ignore_visibility?; end

sig { returns(T.nilable(Prism::Node)) }
def receiver; end

sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end

sig { returns(Symbol) }
def name; end

sig { returns(T.nilable(Prism::Location)) }
def message_loc; end

sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end

sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end

sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end

sig { returns(T.nilable(Prism::Location)) }
def equal_loc; end

sig { returns(T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))) }
def block; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), name: Symbol, message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), equal_loc: T.nilable(Prism::Location), block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))).void }
def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, equal_loc, block); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), name: Symbol, message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), equal_loc: T.nilable(Prism::Location), block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))).returns(Prism::CallNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, equal_loc: self.equal_loc, block: self.block); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def call_operator; end

sig { returns(T.nilable(String)) }
def message; end

sig { returns(T.nilable(String)) }
def opening; end

sig { returns(T.nilable(String)) }
def closing; end

sig { returns(T.nilable(String)) }
def equal; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents the use of an assignment operator on a call. # # foo.bar += baz # ^^^^^^^^^^^^^^ class Prism::CallOperatorWriteNode < Prism::Node

sig { returns(T::Boolean) }
def safe_navigation?; end

sig { returns(T::Boolean) }
def variable_call?; end

sig { returns(T::Boolean) }
def attribute_write?; end

sig { returns(T::Boolean) }
def ignore_visibility?; end

sig { returns(T.nilable(Prism::Node)) }
def receiver; end

sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end

sig { returns(T.nilable(Prism::Location)) }
def message_loc; end

sig { returns(Symbol) }
def read_name; end

sig { returns(Symbol) }
def write_name; end

sig { returns(Symbol) }
def binary_operator; end

sig { returns(Prism::Location) }
def binary_operator_loc; end

sig { returns(Prism::Node) }
def value; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node).void }
def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node).returns(Prism::CallOperatorWriteNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, message_loc: self.message_loc, read_name: self.read_name, write_name: self.write_name, binary_operator: self.binary_operator, binary_operator_loc: self.binary_operator_loc, value: self.value); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def call_operator; end

sig { returns(T.nilable(String)) }
def message; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents the use of the ‘||=` operator on a call. # # foo.bar ||= value # ^^^^^^^^^^^^^^^^^ class Prism::CallOrWriteNode < Prism::Node

sig { returns(T::Boolean) }
def safe_navigation?; end

sig { returns(T::Boolean) }
def variable_call?; end

sig { returns(T::Boolean) }
def attribute_write?; end

sig { returns(T::Boolean) }
def ignore_visibility?; end

sig { returns(T.nilable(Prism::Node)) }
def receiver; end

sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end

sig { returns(T.nilable(Prism::Location)) }
def message_loc; end

sig { returns(Symbol) }
def read_name; end

sig { returns(Symbol) }
def write_name; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { returns(Prism::Node) }
def value; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node).void }
def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator_loc: Prism::Location, value: Prism::Node).returns(Prism::CallOrWriteNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, message_loc: self.message_loc, read_name: self.read_name, write_name: self.write_name, operator_loc: self.operator_loc, value: self.value); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(T.nilable(String)) }
def call_operator; end

sig { returns(T.nilable(String)) }
def message; end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents assigning to a method call. # # foo.bar, = 1 # ^^^^^^^ # # begin # rescue => foo.bar # ^^^^^^^ # end # # for foo.bar in baz do end # ^^^^^^^ class Prism::CallTargetNode < Prism::Node

sig { returns(T::Boolean) }
def safe_navigation?; end

sig { returns(T::Boolean) }
def variable_call?; end

sig { returns(T::Boolean) }
def attribute_write?; end

sig { returns(T::Boolean) }
def ignore_visibility?; end

sig { returns(Prism::Node) }
def receiver; end

sig { returns(Prism::Location) }
def call_operator_loc; end

sig { returns(Symbol) }
def name; end

sig { returns(Prism::Location) }
def message_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: Prism::Node, call_operator_loc: Prism::Location, name: Symbol, message_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: Prism::Node, call_operator_loc: Prism::Location, name: Symbol, message_loc: Prism::Location).returns(Prism::CallTargetNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def call_operator; end

sig { returns(String) }
def message; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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(Prism::LocalVariableTargetNode) }
def target; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, value: Prism::Node, target: Prism::LocalVariableTargetNode, operator_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, value, target, operator_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, value: Prism::Node, target: Prism::LocalVariableTargetNode, operator_loc: Prism::Location).returns(Prism::CapturePatternNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, value: self.value, target: self.target, operator_loc: self.operator_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# Represents the use of a case statement for pattern matching. # # case true # in false # end # ^^^^^^^^^ class Prism::CaseMatchNode < Prism::Node

sig { returns(T.nilable(Prism::Node)) }
def predicate; end

sig { returns(T::Array[Prism::InNode]) }
def conditions; end

sig { returns(T.nilable(Prism::ElseNode)) }
def else_clause; end

sig { returns(Prism::Location) }
def case_keyword_loc; end

sig { returns(Prism::Location) }
def end_keyword_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::InNode], else_clause: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::InNode], else_clause: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location).returns(Prism::CaseMatchNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, predicate: self.predicate, conditions: self.conditions, else_clause: self.else_clause, case_keyword_loc: self.case_keyword_loc, end_keyword_loc: self.end_keyword_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def case_keyword; end

sig { returns(String) }
def end_keyword; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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[Prism::WhenNode]) }
def conditions; end

sig { returns(T.nilable(Prism::ElseNode)) }
def else_clause; end

sig { returns(Prism::Location) }
def case_keyword_loc; end

sig { returns(Prism::Location) }
def end_keyword_loc; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::WhenNode], else_clause: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location).void }
def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::WhenNode], else_clause: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location).returns(Prism::CaseNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, predicate: self.predicate, conditions: self.conditions, else_clause: self.else_clause, case_keyword_loc: self.case_keyword_loc, end_keyword_loc: self.end_keyword_loc); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def case_keyword; end

sig { returns(String) }
def end_keyword; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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(Prism::Location) }
def class_keyword_loc; end

sig { returns(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::CallNode)) }
def constant_path; end

sig { returns(T.nilable(Prism::Location)) }
def inheritance_operator_loc; end

sig { returns(T.nilable(Prism::Node)) }
def superclass; end

sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) }
def body; end

sig { returns(Prism::Location) }
def end_keyword_loc; end

sig { returns(Symbol) }
def name; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Prism::Location, constant_path: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::CallNode), inheritance_operator_loc: T.nilable(Prism::Location), superclass: T.nilable(Prism::Node), body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)), end_keyword_loc: Prism::Location, name: Symbol).void }
def initialize(source, node_id, location, flags, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Prism::Location, constant_path: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::CallNode), inheritance_operator_loc: T.nilable(Prism::Location), superclass: T.nilable(Prism::Node), body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)), end_keyword_loc: Prism::Location, name: Symbol).returns(Prism::ClassNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, locals: self.locals, class_keyword_loc: self.class_keyword_loc, constant_path: self.constant_path, inheritance_operator_loc: self.inheritance_operator_loc, superclass: self.superclass, body: self.body, end_keyword_loc: self.end_keyword_loc, name: self.name); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def class_keyword; end

sig { returns(T.nilable(String)) }
def inheritance_operator; end

sig { returns(String) }
def end_keyword; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end

end

# 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(Prism::Location) }
def name_loc; end

sig { returns(Prism::Location) }
def operator_loc; end

sig { returns(Prism::Node) }
def value; end

sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node).void }
def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end

sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end

sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end

sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end

sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end

sig { params(node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node).returns(Prism::ClassVariableAndWriteNode) }
def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value); end

sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end

sig { returns(String) }
def operator; end

sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end

sig { override.returns(String) }
def inspect; end

sig { override.returns(Symbol) }
def type; end