class Prism::ParametersNode
Represents the list of parameters on a method, block, or lambda definition.
def a(b, c, d) ^^^^^^^ end
Attributes
attr_reader block: BlockParameterNode
?
attr_reader keyword_rest
: Node
?
attr_reader keywords: Array
attr_reader optionals: Array
attr_reader posts: Array
attr_reader requireds: Array
attr_reader rest: Node
?
Public Class Methods
def initialize: (requireds: Array, optionals: Array, rest: Node
?, posts: Array, keywords: Array, keyword_rest
: Node
?, block: BlockParameterNode
?, location: Location
) -> void
# File prism/node.rb, line 13187 def initialize(requireds, optionals, rest, posts, keywords, keyword_rest, block, location) @requireds = requireds @optionals = optionals @rest = rest @posts = posts @keywords = keywords @keyword_rest = keyword_rest @block = block @location = location end
Similar to type
, this method returns a symbol that you can use for splitting on the type of the node without having to do a long === chain. Note that like type
, it will still be slower than using == for a single class, but should be faster in a case statement or an array comparison.
def self.type: () -> Symbol
# File prism/node.rb, line 13300 def self.type :parameters_node end
Public Instance Methods
def accept: (visitor: Visitor
) -> void
# File prism/node.rb, line 13199 def accept(visitor) visitor.visit_parameters_node(self) end
def child_nodes
: () -> Array[nil | Node]
# File prism/node.rb, line 13204 def child_nodes [*requireds, *optionals, rest, *posts, *keywords, keyword_rest, block] end
def comment_targets
: () -> Array[Node | Location]
# File prism/node.rb, line 13222 def comment_targets [*requireds, *optionals, *rest, *posts, *keywords, *keyword_rest, *block] end
def compact_child_nodes
: () -> Array
# File prism/node.rb, line 13209 def compact_child_nodes compact = [] 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
def copy: (**params) -> ParametersNode
# File prism/node.rb, line 13227 def copy(**params) ParametersNode.new( params.fetch(:requireds) { requireds }, params.fetch(:optionals) { optionals }, params.fetch(:rest) { rest }, params.fetch(:posts) { posts }, params.fetch(:keywords) { keywords }, params.fetch(:keyword_rest) { keyword_rest }, params.fetch(:block) { block }, params.fetch(:location) { location }, ) end
def deconstruct_keys
: (keys: Array) -> Hash[Symbol, nil | Node
| Array | String | Token
| Array | Location]
# File prism/node.rb, line 13244 def deconstruct_keys(keys) { requireds: requireds, optionals: optionals, rest: rest, posts: posts, keywords: keywords, keyword_rest: keyword_rest, block: block, location: location } end
def inspect(inspector: NodeInspector) -> String
# File prism/node.rb, line 13249 def inspect(inspector = NodeInspector.new) inspector << inspector.header(self) inspector << "├── requireds: #{inspector.list("#{inspector.prefix}│ ", requireds)}" inspector << "├── optionals: #{inspector.list("#{inspector.prefix}│ ", optionals)}" if (rest = self.rest).nil? inspector << "├── rest: ∅\n" else inspector << "├── rest:\n" inspector << rest.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix) end inspector << "├── posts: #{inspector.list("#{inspector.prefix}│ ", posts)}" inspector << "├── keywords: #{inspector.list("#{inspector.prefix}│ ", keywords)}" if (keyword_rest = self.keyword_rest).nil? inspector << "├── keyword_rest: ∅\n" else inspector << "├── keyword_rest:\n" inspector << keyword_rest.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix) end if (block = self.block).nil? inspector << "└── block: ∅\n" else inspector << "└── block:\n" inspector << block.inspect(inspector.child_inspector(" ")).delete_prefix(inspector.prefix) end inspector.to_str end
Mirrors the Method#parameters method.
# File prism/node_ext.rb, line 149 def signature names = [] requireds.each do |param| names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name]) end optionals.each { |param| names << [:opt, param.name] } names << [:rest, rest.name || :*] if rest posts.each do |param| names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name]) end # Regardless of the order in which the keywords were defined, the required # keywords always come first followed by the optional keywords. keyopt = [] 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
Sometimes you want to check an instance of a node against a list of classes to see what kind of behavior to perform. Usually this is done by calling ‘[cls1, cls2].include?(node.class)` or putting the node into a case statement and doing `case node; when cls1; when cls2; end`. Both of these approaches are relatively slow because of the constant lookups, method calls, and/or array allocations.
Instead, you can call type
, which will return to you a symbol that you can use for comparison. This is faster than the other approaches because it uses a single integer comparison, but also because if you’re on CRuby you can take advantage of the fact that case statements with all symbol keys will use a jump table.
def type: () -> Symbol
# File prism/node.rb, line 13290 def type :parameters_node end