Represents a write to a multi-target expression.
a, b, c = 1, 2, 3 ^^^^^^^^^^^^^^^^^
Represents the targets expressions before a splat node.
a, b, * = 1, 2, 3, 4, 5 ^^^^
The splat node can be absent, in that case all target expressions are in the left field.
a, b, c = 1, 2, 3, 4, 5 ^^^^^^^
Represents a splat node in the target expression.
a, b, *c = 1, 2, 3, 4 ^^
The variable can be empty, this results in a ‘SplatNode` with a `nil` expression field.
a, b, * = 1, 2, 3, 4 ^
If the ‘*` is omitted, this field will contain an `ImplicitRestNode`
a, b, = 1, 2, 3, 4 ^
Represents the targets expressions after a splat node.
a, *, b, c = 1, 2, 3, 4, 5 ^^^^
The value to write to the targets. It can be any [non-void expression](github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
a, b, c = 1, 2, 3 ^^^^^^^
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13188
def initialize(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value)
@source = source
@node_id = node_id
@location = location
@flags = flags
@lefts = lefts
@rest = rest
@rights = rights
@lparen_loc = lparen_loc
@rparen_loc = rparen_loc
@operator_loc = operator_loc
@value = value
end
Initialize a new MultiWriteNode
node.
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13365
def self.type
:multi_write_node
end
Return a symbol representation of this node type. See ‘Node::type`.
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13371
def ===(other)
other.is_a?(MultiWriteNode) &&
(lefts.length == other.lefts.length) &&
lefts.zip(other.lefts).all? { |left, right| left === right } &&
(rest === other.rest) &&
(rights.length == other.rights.length) &&
rights.zip(other.rights).all? { |left, right| left === right } &&
(lparen_loc.nil? == other.lparen_loc.nil?) &&
(rparen_loc.nil? == other.rparen_loc.nil?) &&
(operator_loc.nil? == other.operator_loc.nil?) &&
(value === other.value)
end
Implements case-equality for the node. This is effectively == but without comparing the value of locations. Locations are checked only for presence.
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13203
def accept(visitor)
visitor.visit_multi_write_node(self)
end
def accept: (Visitor
visitor) -> void
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13208
def child_nodes
[*lefts, rest, *rights, value]
end
def child_nodes
: () -> Array[nil | Node]
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13223
def comment_targets
[*lefts, *rest, *rights, *lparen_loc, *rparen_loc, operator_loc, value] #: Array[Prism::node | Location]
end
def comment_targets
: () -> Array[Node | Location]
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13213
def compact_child_nodes
compact = [] #: Array[Prism::node]
compact.concat(lefts)
compact << rest if rest
compact.concat(rights)
compact << value
compact
end
def compact_child_nodes
: () -> Array
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13228
def copy(node_id: self.node_id, location: self.location, flags: self.flags, lefts: self.lefts, rest: self.rest, rights: self.rights, lparen_loc: self.lparen_loc, rparen_loc: self.rparen_loc, operator_loc: self.operator_loc, value: self.value)
MultiWriteNode.new(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value)
end
def copy: (?node_id: Integer
, ?location: Location
, ?flags: Integer
, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode
| ClassVariableTargetNode
| GlobalVariableTargetNode
| ConstantTargetNode
| ConstantPathTargetNode
| CallTargetNode
| IndexTargetNode
| MultiTargetNode
| BackReferenceReadNode
| NumberedReferenceReadNode], ?rest: ImplicitRestNode
| SplatNode
| nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode
| ClassVariableTargetNode
| GlobalVariableTargetNode
| ConstantTargetNode
| ConstantPathTargetNode
| CallTargetNode
| IndexTargetNode
| MultiTargetNode
| BackReferenceReadNode
| NumberedReferenceReadNode], ?lparen_loc: Location
?, ?rparen_loc: Location
?, ?operator_loc: Location
, ?value: Prism::node) -> MultiWriteNode
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13236
def deconstruct_keys(keys)
{ node_id: node_id, location: location, lefts: lefts, rest: rest, rights: rights, lparen_loc: lparen_loc, rparen_loc: rparen_loc, operator_loc: operator_loc, value: value }
end
def deconstruct_keys
: (Array keys) -> { node_id: Integer
, location: Location
, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode
| ClassVariableTargetNode
| GlobalVariableTargetNode
| ConstantTargetNode
| ConstantPathTargetNode
| CallTargetNode
| IndexTargetNode
| MultiTargetNode
| BackReferenceReadNode
| NumberedReferenceReadNode], rest: ImplicitRestNode
| SplatNode
| nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode
| ClassVariableTargetNode
| GlobalVariableTargetNode
| ConstantTargetNode
| ConstantPathTargetNode
| CallTargetNode
| IndexTargetNode
| MultiTargetNode
| BackReferenceReadNode
| NumberedReferenceReadNode], lparen_loc
: Location
?, rparen_loc
: Location
?, operator_loc
: Location
, value: Prism::node }
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13355
def inspect
InspectVisitor.compose(self)
end
def inspect -> String
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13340
def lparen
lparen_loc&.slice
end
def lparen: () -> String
?
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13277
def lparen_loc
location = @lparen_loc
case location
when nil
nil
when Location
location
else
@lparen_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
end
end
The location of the opening parenthesis.
(a, b, c) = 1, 2, 3 ^
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13350
def operator
operator_loc.slice
end
def operator: () -> String
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13321
def operator_loc
location = @operator_loc
return location if location.is_a?(Location)
@operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
end
The location of the operator.
a, b, c = 1, 2, 3 ^
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13345
def rparen
rparen_loc&.slice
end
def rparen: () -> String
?
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13299
def rparen_loc
location = @rparen_loc
case location
when nil
nil
when Location
location
else
@rparen_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
end
end
The location of the closing parenthesis.
(a, b, c) = 1, 2, 3 ^
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13291
def save_lparen_loc(repository)
repository.enter(node_id, :lparen_loc) unless @lparen_loc.nil?
end
Save the lparen_loc
location using the given saved source so that it can be retrieved later.
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13329
def save_operator_loc(repository)
repository.enter(node_id, :operator_loc)
end
Save the operator_loc
location using the given saved source so that it can be retrieved later.
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13313
def save_rparen_loc(repository)
repository.enter(node_id, :rparen_loc) unless @rparen_loc.nil?
end
Save the rparen_loc
location using the given saved source so that it can be retrieved later.
# File tmp/rubies/ruby-3.4.1/lib/prism/node.rb, line 13360
def type
:multi_write_node
end
Return a symbol representation of this node type. See ‘Node#type`.