class Prism::FindPatternNode

Represents a find pattern in pattern matching.

foo in *bar, baz, *qux       ^^^^^^^^^^^^^^^foo in [*bar, baz, *qux]       ^^^^^^^^^^^^^^^^^foo in Foo(*bar, baz, *qux)       ^^^^^^^^^^^^^^^^^^^^foo => *bar, baz, *qux       ^^^^^^^^^^^^^^^

Attributes

constant[R]

Represents the optional constant preceding the pattern

foo in Foo(*bar, baz, *qux)       ^^^

left[R]

Represents the first wildcard node in the pattern.

foo in *bar, baz, *qux       ^^^^foo in Foo(*bar, baz, *qux)           ^^^^

requireds[R]

Represents the nodes in between the wildcards.

foo in *bar, baz, *qux             ^^^foo in Foo(*bar, baz, 1, *qux)                 ^^^^^^

right[R]

Represents the second wildcard node in the pattern.

foo in *bar, baz, *qux                  ^^^^foo in Foo(*bar, baz, *qux)                      ^^^^

Public Class Methods

new(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc)

Source

# File lib/prism/node.rb, line 6883definitialize(source,node_id,location,flags,constant,left,requireds,right,opening_loc,closing_loc)@source =source@node_id =node_id@location =location@flags =flags@constant =constant@left =left@requireds =requireds@right =right@opening_loc =opening_loc@closing_loc =closing_locend

Initialize a newFindPatternNode node.

type()

Source

# File lib/prism/node.rb, line 7038defself.type:find_pattern_nodeend

Return a symbol representation of this node type. SeeNode::type.

Public Instance Methods

===(other)

Source

# File lib/prism/node.rb, line 7044def===(other)other.is_a?(FindPatternNode)&&    (constant===other.constant)&&    (left===other.left)&&    (requireds.length==other.requireds.length)&&requireds.zip(other.requireds).all? {|left,right|left===right }&&    (right===other.right)&&    (opening_loc.nil?==other.opening_loc.nil?)&&    (closing_loc.nil?==other.closing_loc.nil?)end

Implements case-equality for the node. This is effectively == but without comparing the value of locations. Locations are checked only for presence.

accept(visitor)

Source

# File lib/prism/node.rb, line 6897defaccept(visitor)visitor.visit_find_pattern_node(self)end

def accept: (Visitor visitor) -> void

child_nodes()

Source

# File lib/prism/node.rb, line 6902defchild_nodes  [constant,left,*requireds,right]end

defchild_nodes: () ->Array

Also aliased as:deconstruct

closing()

Source

# File lib/prism/node.rb, line 7023defclosingclosing_loc&.sliceend

def closing: () ->String?

closing_loc()

Source

# File lib/prism/node.rb, line 6999defclosing_loclocation =@closing_loccaselocationwhennilnilwhenLocationlocationelse@closing_loc =Location.new(source,location>>32,location&0xFFFFFFFF)endend

The location of the closing brace.

foo in [*bar, baz, *qux]                       ^foo in Foo(*bar, baz, *qux)                          ^

comment_targets()

Source

# File lib/prism/node.rb, line 6917defcomment_targets  [*constant,left,*requireds,right,*opening_loc,*closing_loc]#: Array[Prism::node | Location]end

defcomment_targets: () -> Array[Node | Location]

compact_child_nodes()

Source

# File lib/prism/node.rb, line 6907defcompact_child_nodescompact = []#: Array[Prism::node]compact<<constantifconstantcompact<<leftcompact.concat(requireds)compact<<rightcompactend

defcompact_child_nodes: () ->Array

copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, left: self.left, requireds: self.requireds, right: self.right, opening_loc: self.opening_loc, closing_loc: self.closing_loc)

Source

# File lib/prism/node.rb, line 6922defcopy(node_id:self.node_id,location:self.location,flags:self.flags,constant:self.constant,left:self.left,requireds:self.requireds,right:self.right,opening_loc:self.opening_loc,closing_loc:self.closing_loc)FindPatternNode.new(source,node_id,location,flags,constant,left,requireds,right,opening_loc,closing_loc)end

def copy: (?node_id:Integer, ?location:Location, ?flags:Integer, ?constant:ConstantPathNode |ConstantReadNode | nil, ?left:SplatNode, ?requireds:Array, ?right:SplatNode |MissingNode, ?opening_loc:Location?, ?closing_loc:Location?) ->FindPatternNode

deconstruct()

def deconstruct: () ->Array

Alias for:child_nodes

deconstruct_keys(keys)

Source

# File lib/prism/node.rb, line 6930defdeconstruct_keys(keys)  {node_id:node_id,location:location,constant:constant,left:left,requireds:requireds,right:right,opening_loc:opening_loc,closing_loc:closing_loc }end

defdeconstruct_keys: (Array keys) -> { node_id:Integer, location:Location, constant:ConstantPathNode |ConstantReadNode | nil, left:SplatNode, requireds:Array, right:SplatNode |MissingNode,opening_loc:Location?,closing_loc:Location? }

inspect()

Source

# File lib/prism/node.rb, line 7028definspectInspectVisitor.compose(self)end

def inspect ->String

opening()

Source

# File lib/prism/node.rb, line 7018defopeningopening_loc&.sliceend

def opening: () ->String?

opening_loc()

Source

# File lib/prism/node.rb, line 6974defopening_loclocation =@opening_loccaselocationwhennilnilwhenLocationlocationelse@opening_loc =Location.new(source,location>>32,location&0xFFFFFFFF)endend

The location of the opening brace.

foo in [*bar, baz, *qux]       ^foo in Foo(*bar, baz, *qux)          ^

save_closing_loc(repository)

Source

# File lib/prism/node.rb, line 7013defsave_closing_loc(repository)repository.enter(node_id,:closing_loc)unless@closing_loc.nil?end

Save theclosing_loc location using the given saved source so that it can be retrieved later.

save_opening_loc(repository)

Source

# File lib/prism/node.rb, line 6988defsave_opening_loc(repository)repository.enter(node_id,:opening_loc)unless@opening_loc.nil?end

Save theopening_loc location using the given saved source so that it can be retrieved later.

type()

Source

# File lib/prism/node.rb, line 7033deftype:find_pattern_nodeend

Return a symbol representation of this node type. SeeNode#type.

Movatterモバイル変換

class Prism::FindPatternNode