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.



14302
14303
14304
14305
14306
14307
14308
14309
14310
14311
14312
14313
14314
 
# File 'lib/prism/node.rb', line 14302

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?



14376
14377
14378
 
# File 'lib/prism/node.rb', line 14376

def block
  @block
end

#keyword_rest ⇒ Object (readonly)

attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil



14373
14374
14375
 
# File 'lib/prism/node.rb', line 14373

def keyword_rest
  @keyword_rest
end

#keywords ⇒ Object (readonly)

attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]



14370
14371
14372
 
# File 'lib/prism/node.rb', line 14370

def keywords
  @keywords
end

#optionals ⇒ Object (readonly)

attr_reader optionals: Array



14361
14362
14363
 
# File 'lib/prism/node.rb', line 14361

def optionals
  @optionals
end

#posts ⇒ Object (readonly)

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



14367
14368
14369
 
# File 'lib/prism/node.rb', line 14367

def posts
  @posts
end

#requireds ⇒ Object (readonly)

attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]



14358
14359
14360
 
# File 'lib/prism/node.rb', line 14358

def requireds
  @requireds
end

#rest ⇒ Object (readonly)

attr_reader rest: RestParameterNode | ImplicitRestNode | nil



14364
14365
14366
 
# File 'lib/prism/node.rb', line 14364

def rest
  @rest
end

Class Method Details

.type ⇒ Object

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



14389
14390
14391
 
# File 'lib/prism/node.rb', line 14389

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.



14395
14396
14397
14398
14399
14400
14401
14402
14403
14404
14405
14406
14407
14408
 
# File 'lib/prism/node.rb', line 14395

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



14317
14318
14319
 
# File 'lib/prism/node.rb', line 14317

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

#child_nodes ⇒ Object Also known as: deconstruct

def child_nodes: () -> Array



14322
14323
14324
 
# File 'lib/prism/node.rb', line 14322

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

#comment_targets ⇒ Object

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



14340
14341
14342
 
# File 'lib/prism/node.rb', line 14340

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



14327
14328
14329
14330
14331
14332
14333
14334
14335
14336
14337
 
# File 'lib/prism/node.rb', line 14327

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



14345
14346
14347
 
# File 'lib/prism/node.rb', line 14345

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



14353
14354
14355
 
# File 'lib/prism/node.rb', line 14353

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



14379
14380
14381
 
# File 'lib/prism/node.rb', line 14379

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



14384
14385
14386
 
# File 'lib/prism/node.rb', line 14384

def type
  :parameters_node
end