Class: Prism::ParametersNode

Inherits:
PrismNode
  • Object
show all
Defined in:
lib/prism/node.rb,
lib/prism/node_ext.rb,
ext/prism/api_node.c

Overview

Represents the list of parameters on a method, block, or lambda definition.

def a(b, c, d)
      ^^^^^^^
end

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(source, node_id, location, flags, requireds, optionals, rest, posts, keywords, keyword_rest, block) ⇒ ParametersNode

Initialize a new ParametersNode node.



12733
12734
12735
12736
12737
12738
12739
12740
12741
12742
12743
12744
12745
 
# File 'lib/prism/node.rb', line 12733

def initialize(source, node_id, location, flags, requireds, optionals, rest, posts, keywords, keyword_rest, block)
  @source = source
  @node_id = node_id
  @location = location
  @flags = flags
  @requireds = requireds
  @optionals = optionals
  @rest = rest
  @posts = posts
  @keywords = keywords
  @keyword_rest = keyword_rest
  @block = block
end

Instance Attribute Details

#block ⇒ Object (readonly)

attr_reader block: BlockParameterNode?



12807
12808
12809
 
# File 'lib/prism/node.rb', line 12807

def block
  @block
end

#keyword_rest ⇒ Object (readonly)

attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil



12804
12805
12806
 
# File 'lib/prism/node.rb', line 12804

def keyword_rest
  @keyword_rest
end

#keywords ⇒ Object (readonly)

attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]



12801
12802
12803
 
# File 'lib/prism/node.rb', line 12801

def keywords
  @keywords
end

#optionals ⇒ Object (readonly)

attr_reader optionals: Array



12792
12793
12794
 
# File 'lib/prism/node.rb', line 12792

def optionals
  @optionals
end

#posts ⇒ Object (readonly)

attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode]



12798
12799
12800
 
# File 'lib/prism/node.rb', line 12798

def posts
  @posts
end

#requireds ⇒ Object (readonly)

attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]



12789
12790
12791
 
# File 'lib/prism/node.rb', line 12789

def requireds
  @requireds
end

#rest ⇒ Object (readonly)

attr_reader rest: RestParameterNode | ImplicitRestNode | nil



12795
12796
12797
 
# File 'lib/prism/node.rb', line 12795

def rest
  @rest
end

Class Method Details

.type ⇒ Object

Return a symbol representation of this node type. See ‘Node::type`.



12820
12821
12822
 
# File 'lib/prism/node.rb', line 12820

def self.type
  :parameters_node
end

Instance Method Details

#===(other) ⇒ Object

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



12826
12827
12828
12829
12830
12831
12832
12833
12834
12835
12836
12837
12838
12839
 
# File 'lib/prism/node.rb', line 12826

def ===(other)
  other.is_a?(ParametersNode) &&
    (requireds.length == other.requireds.length) &&
    requireds.zip(other.requireds).all? { |left, right| left === right } &&
    (optionals.length == other.optionals.length) &&
    optionals.zip(other.optionals).all? { |left, right| left === right } &&
    (rest === other.rest) &&
    (posts.length == other.posts.length) &&
    posts.zip(other.posts).all? { |left, right| left === right } &&
    (keywords.length == other.keywords.length) &&
    keywords.zip(other.keywords).all? { |left, right| left === right } &&
    (keyword_rest === other.keyword_rest) &&
    (block === other.block)
end

#accept(visitor) ⇒ Object

def accept: (Visitor visitor) -> void



12748
12749
12750
 
# File 'lib/prism/node.rb', line 12748

def accept(visitor)
  visitor.visit_parameters_node(self)
end

#child_nodes ⇒ Object Also known as: deconstruct

def child_nodes: () -> Array[nil | Node]



12753
12754
12755
 
# File 'lib/prism/node.rb', line 12753

def child_nodes
  [*requireds, *optionals, rest, *posts, *keywords, keyword_rest, block]
end

#comment_targets ⇒ Object

def comment_targets: () -> Array[Node | Location]



12771
12772
12773
 
# File 'lib/prism/node.rb', line 12771

def comment_targets
  [*requireds, *optionals, *rest, *posts, *keywords, *keyword_rest, *block] #: Array[Prism::node | Location]
end

#compact_child_nodes ⇒ Object

def compact_child_nodes: () -> Array



12758
12759
12760
12761
12762
12763
12764
12765
12766
12767
12768
 
# File 'lib/prism/node.rb', line 12758

def compact_child_nodes
  compact = [] #: Array[Prism::node]
  compact.concat(requireds)
  compact.concat(optionals)
  compact << rest if rest
  compact.concat(posts)
  compact.concat(keywords)
  compact << keyword_rest if keyword_rest
  compact << block if block
  compact
end

#copy(node_id: self.node_id, location: self.location, flags: self.flags, requireds: self.requireds, optionals: self.optionals, rest: self.rest, posts: self.posts, keywords: self.keywords, keyword_rest: self.keyword_rest, block: self.block) ⇒ Object

def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array, ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?) -> ParametersNode



12776
12777
12778
 
# File 'lib/prism/node.rb', line 12776

def copy(node_id: self.node_id, location: self.location, flags: self.flags, requireds: self.requireds, optionals: self.optionals, rest: self.rest, posts: self.posts, keywords: self.keywords, keyword_rest: self.keyword_rest, block: self.block)
  ParametersNode.new(source, node_id, location, flags, requireds, optionals, rest, posts, keywords, keyword_rest, block)
end

#deconstruct_keys(keys) ⇒ Object

def deconstruct_keys: (Array keys) -> { node_id: Integer, location: Location, requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array, rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode? }



12784
12785
12786
 
# File 'lib/prism/node.rb', line 12784

def deconstruct_keys(keys)
  { node_id: node_id, location: location, requireds: requireds, optionals: optionals, rest: rest, posts: posts, keywords: keywords, keyword_rest: keyword_rest, block: block }
end

#inspect ⇒ Object

def inspect -> String



12810
12811
12812
 
# File 'lib/prism/node.rb', line 12810

def inspect
  InspectVisitor.compose(self)
end

#signature ⇒ Object

Mirrors the Method#parameters method.



269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
 
# File 'lib/prism/node_ext.rb', line 269

def signature
  names = [] #: Array[[Symbol, Symbol] | [Symbol]]

  requireds.each do |param|
    names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name])
  end

  optionals.each { |param| names << [:opt, param.name] }

  if rest && rest.is_a?(RestParameterNode)
    names << [:rest, rest.name || :*]
  end

  posts.each do |param|
    case param
    when MultiTargetNode
      names << [:req]
    when NoKeywordsParameterNode, KeywordRestParameterNode, ForwardingParameterNode
      # Invalid syntax, e.g. "def f(**nil, ...)" moves the NoKeywordsParameterNode to posts
      raise "Invalid syntax"
    else
      names << [:req, param.name]
    end
  end

  # Regardless of the order in which the keywords were defined, the required
  # keywords always come first followed by the optional keywords.
  keyopt = [] #: Array[OptionalKeywordParameterNode]
  keywords.each do |param|
    if param.is_a?(OptionalKeywordParameterNode)
      keyopt << param
    else
      names << [:keyreq, param.name]
    end
  end

  keyopt.each { |param| names << [:key, param.name] }

  case keyword_rest
  when ForwardingParameterNode
    names.concat([[:rest, :*], [:keyrest, :**], [:block, :&]])
  when KeywordRestParameterNode
    names << [:keyrest, keyword_rest.name || :**]
  when NoKeywordsParameterNode
    names << [:nokey]
  end

  names << [:block, block.name || :&] if block
  names
end

#type ⇒ Object

Return a symbol representation of this node type. See ‘Node#type`.



12815
12816
12817
 
# File 'lib/prism/node.rb', line 12815

def type
  :parameters_node
end