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.



15188
15189
15190
15191
15192
15193
15194
15195
15196
15197
15198
15199
15200
 
# File 'lib/prism/node.rb', line 15188

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?



15275
15276
15277
 
# File 'lib/prism/node.rb', line 15275

def block
  @block
end

#keyword_rest ⇒ Object (readonly)

attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil



15272
15273
15274
 
# File 'lib/prism/node.rb', line 15272

def keyword_rest
  @keyword_rest
end

#keywords ⇒ Object (readonly)

attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]



15269
15270
15271
 
# File 'lib/prism/node.rb', line 15269

def keywords
  @keywords
end

#optionals ⇒ Object (readonly)

attr_reader optionals: Array



15260
15261
15262
 
# File 'lib/prism/node.rb', line 15260

def optionals
  @optionals
end

#posts ⇒ Object (readonly)

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



15266
15267
15268
 
# File 'lib/prism/node.rb', line 15266

def posts
  @posts
end

#requireds ⇒ Object (readonly)

attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]



15257
15258
15259
 
# File 'lib/prism/node.rb', line 15257

def requireds
  @requireds
end

#rest ⇒ Object (readonly)

attr_reader rest: RestParameterNode | ImplicitRestNode | nil



15263
15264
15265
 
# File 'lib/prism/node.rb', line 15263

def rest
  @rest
end

Class Method Details

.type ⇒ Object

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



15288
15289
15290
 
# File 'lib/prism/node.rb', line 15288

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.



15294
15295
15296
15297
15298
15299
15300
15301
15302
15303
15304
15305
15306
15307
 
# File 'lib/prism/node.rb', line 15294

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



15203
15204
15205
 
# File 'lib/prism/node.rb', line 15203

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

#child_nodes ⇒ Object Also known as: deconstruct

def child_nodes: () -> Array



15208
15209
15210
 
# File 'lib/prism/node.rb', line 15208

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

#comment_targets ⇒ Object

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



15239
15240
15241
 
# File 'lib/prism/node.rb', line 15239

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



15226
15227
15228
15229
15230
15231
15232
15233
15234
15235
15236
 
# File 'lib/prism/node.rb', line 15226

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



15244
15245
15246
 
# File 'lib/prism/node.rb', line 15244

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? }



15252
15253
15254
 
# File 'lib/prism/node.rb', line 15252

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

#each_child_node {|rest| ... } ⇒ Object

def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator

Yields:



15213
15214
15215
15216
15217
15218
15219
15220
15221
15222
15223
 
# File 'lib/prism/node.rb', line 15213

def each_child_node
  return to_enum(:each_child_node) unless block_given?

  requireds.each { |node| yield node }
  optionals.each { |node| yield node }
  yield rest if rest
  posts.each { |node| yield node }
  keywords.each { |node| yield node }
  yield keyword_rest if keyword_rest
  yield block if block
end

#inspect ⇒ Object

def inspect -> String



15278
15279
15280
 
# File 'lib/prism/node.rb', line 15278

def inspect
  InspectVisitor.compose(self)
end

#signature ⇒ Object

Mirrors the Method#parameters method.



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
319
320
321
 
# File 'lib/prism/node_ext.rb', line 272

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`.



15283
15284
15285
 
# File 'lib/prism/node.rb', line 15283

def type
  :parameters_node
end