class Prism::IndexTargetNode
^^^^^^^^
for foo in baz do end
end
^^^^^^^^
rescue => foo[bar]<br>begin<br><br>^^^^^^^^<br>foo, = 1
Represents assigning to an index.
def self.type
def self.type :index_target_node end
def ===(other)
Implements case-equality for the node. This is effectively == but without
def ===(other) other.is_a?(IndexTargetNode) && (flags === other.flags) && (receiver === other.receiver) && (opening_loc.nil? == other.opening_loc.nil?) && (arguments === other.arguments) && (closing_loc.nil? == other.closing_loc.nil?) && (block === other.block) end
def accept(visitor)
def accept(visitor) visitor.visit_index_target_node(self) end
def attribute_write?
def attribute_write? flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE) end
def child_nodes
def child_nodes [receiver, arguments, block] end
def closing
def closing closing_loc.slice end
def closing_loc
def closing_loc location = @closing_loc return location if location.is_a?(Location) @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF) end
def comment_targets
def comment_targets [receiver, opening_loc, *arguments, closing_loc, *block] #: Array[Prism::node | Location] end
def compact_child_nodes
def compact_child_nodes compact = [] #: Array[Prism::node] compact << receiver compact << arguments if arguments compact << block if block compact end
def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block)
def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block) IndexTargetNode.new(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block) end
def deconstruct_keys(keys)
def deconstruct_keys(keys) { node_id: node_id, location: location, receiver: receiver, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block } end
def ignore_visibility?
def ignore_visibility? flags.anybits?(CallNodeFlags::IGNORE_VISIBILITY) end
def initialize(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block)
def initialize(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block) @source = source @node_id = node_id @location = location @flags = flags @receiver = receiver @opening_loc = opening_loc @arguments = arguments @closing_loc = closing_loc @block = block end
def inspect
def inspect InspectVisitor.compose(self) end
def opening
def opening opening_loc.slice end
def opening_loc
def opening_loc location = @opening_loc return location if location.is_a?(Location) @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF) end
def safe_navigation?
def safe_navigation? flags.anybits?(CallNodeFlags::SAFE_NAVIGATION) end
def save_closing_loc(repository)
Save the closing_loc location using the given saved source so that
def save_closing_loc(repository) repository.enter(node_id, :closing_loc) end
def save_opening_loc(repository)
Save the opening_loc location using the given saved source so that
def save_opening_loc(repository) repository.enter(node_id, :opening_loc) end
def type
def type :index_target_node end
def variable_call?
def variable_call? flags.anybits?(CallNodeFlags::VARIABLE_CALL) end